diff --git a/.gitignore b/.gitignore
index 7d4cb73d..7334737e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -235,3 +235,4 @@ dist
 .DS_Store
 CMakeUserPresets.json
 Brewfile.lock.json
+!/vendor/**/out
diff --git a/DEPENDENCIES b/DEPENDENCIES
index f16c548e..3892a640 100644
--- a/DEPENDENCIES
+++ b/DEPENDENCIES
@@ -1,4 +1,4 @@
 vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
-core https://github.com/sourcemeta/core 4b948ea794732147e017281c523c1b6f934c8174
-blaze https://github.com/sourcemeta/blaze 32e5c5d68aaad434bedb0a2c59d86e0a08478057
+core https://github.com/sourcemeta/core 5dabb7f983b54e302b35ab74547b58c86576537b
+blaze https://github.com/sourcemeta/blaze f25c2ab22cb13964a47be77acb8bbcc01ad1f2dd
 bootstrap https://github.com/twbs/bootstrap 1a6fdfae6be09b09eaced8f0e442ca6f7680a61e
diff --git a/src/compiler/mapper/enum_8_bit.h b/src/compiler/mapper/enum_8_bit.h
index e5cc8806..f5c6032e 100644
--- a/src/compiler/mapper/enum_8_bit.h
+++ b/src/compiler/mapper/enum_8_bit.h
@@ -5,15 +5,14 @@ class Enum8Bit final : public sourcemeta::blaze::SchemaTransformRule {
   using reframe_after_transform = std::true_type;
   Enum8Bit() : sourcemeta::blaze::SchemaTransformRule{"enum_8_bit", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/enum_8_bit_top_level.h b/src/compiler/mapper/enum_8_bit_top_level.h
index 0a1ab28c..7810e8f4 100644
--- a/src/compiler/mapper/enum_8_bit_top_level.h
+++ b/src/compiler/mapper/enum_8_bit_top_level.h
@@ -5,15 +5,14 @@ class Enum8BitTopLevel final : public sourcemeta::blaze::SchemaTransformRule {
   Enum8BitTopLevel()
       : sourcemeta::blaze::SchemaTransformRule{"enum_8_bit_top_level", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/enum_arbitrary.h b/src/compiler/mapper/enum_arbitrary.h
index b95e13db..34b4b5a9 100644
--- a/src/compiler/mapper/enum_arbitrary.h
+++ b/src/compiler/mapper/enum_arbitrary.h
@@ -6,15 +6,14 @@ class EnumArbitrary final : public sourcemeta::blaze::SchemaTransformRule {
   EnumArbitrary()
       : sourcemeta::blaze::SchemaTransformRule{"enum_arbitrary", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/enum_singleton.h b/src/compiler/mapper/enum_singleton.h
index 2690b92e..bc61d34d 100644
--- a/src/compiler/mapper/enum_singleton.h
+++ b/src/compiler/mapper/enum_singleton.h
@@ -5,15 +5,14 @@ class EnumSingleton final : public sourcemeta::blaze::SchemaTransformRule {
   EnumSingleton()
       : sourcemeta::blaze::SchemaTransformRule{"enum_singleton", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_bounded_8_bit.h b/src/compiler/mapper/integer_bounded_8_bit.h
index 0c5a524b..c9661da6 100644
--- a/src/compiler/mapper/integer_bounded_8_bit.h
+++ b/src/compiler/mapper/integer_bounded_8_bit.h
@@ -5,15 +5,14 @@ class IntegerBounded8Bit final : public sourcemeta::blaze::SchemaTransformRule {
   IntegerBounded8Bit()
       : sourcemeta::blaze::SchemaTransformRule{"integer_bounded_8_bit", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_bounded_greater_than_8_bit.h b/src/compiler/mapper/integer_bounded_greater_than_8_bit.h
index 7983adec..85f8fe65 100644
--- a/src/compiler/mapper/integer_bounded_greater_than_8_bit.h
+++ b/src/compiler/mapper/integer_bounded_greater_than_8_bit.h
@@ -7,15 +7,14 @@ class IntegerBoundedGreaterThan8Bit final
       : sourcemeta::blaze::SchemaTransformRule{
             "integer_bounded_greater_than_8_bit", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_bounded_multiplier_8_bit.h b/src/compiler/mapper/integer_bounded_multiplier_8_bit.h
index 2a5eb044..29414f41 100644
--- a/src/compiler/mapper/integer_bounded_multiplier_8_bit.h
+++ b/src/compiler/mapper/integer_bounded_multiplier_8_bit.h
@@ -7,15 +7,14 @@ class IntegerBoundedMultiplier8Bit final
       : sourcemeta::blaze::SchemaTransformRule{
             "integer_bounded_multiplier_8_bit", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     if (location.dialect != "https://json-schema.org/draft/2020-12/schema" ||
         !vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h b/src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h
index 8a304b99..267399c4 100644
--- a/src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h
+++ b/src/compiler/mapper/integer_bounded_multiplier_greater_than_8_bit.h
@@ -7,15 +7,14 @@ class IntegerBoundedMultiplierGreaterThan8Bit final
       : sourcemeta::blaze::SchemaTransformRule{
             "integer_bounded_multiplier_greater_than_8_bit", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     if (location.dialect != "https://json-schema.org/draft/2020-12/schema" ||
         !vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_lower_bound.h b/src/compiler/mapper/integer_lower_bound.h
index 25071e39..d9a68ff3 100644
--- a/src/compiler/mapper/integer_lower_bound.h
+++ b/src/compiler/mapper/integer_lower_bound.h
@@ -5,15 +5,14 @@ class IntegerLowerBound final : public sourcemeta::blaze::SchemaTransformRule {
   IntegerLowerBound()
       : sourcemeta::blaze::SchemaTransformRule{"integer_lower_bound", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_lower_bound_multiplier.h b/src/compiler/mapper/integer_lower_bound_multiplier.h
index b34f8c32..e0a1195c 100644
--- a/src/compiler/mapper/integer_lower_bound_multiplier.h
+++ b/src/compiler/mapper/integer_lower_bound_multiplier.h
@@ -7,15 +7,14 @@ class IntegerLowerBoundMultiplier final
       : sourcemeta::blaze::SchemaTransformRule{"integer_lower_bound_multiplier",
                                                ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_unbound.h b/src/compiler/mapper/integer_unbound.h
index 32fca495..506df0bd 100644
--- a/src/compiler/mapper/integer_unbound.h
+++ b/src/compiler/mapper/integer_unbound.h
@@ -5,15 +5,14 @@ class IntegerUnbound final : public sourcemeta::blaze::SchemaTransformRule {
   IntegerUnbound()
       : sourcemeta::blaze::SchemaTransformRule{"integer_unbound", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_unbound_multiplier.h b/src/compiler/mapper/integer_unbound_multiplier.h
index 4d060b24..2e839fde 100644
--- a/src/compiler/mapper/integer_unbound_multiplier.h
+++ b/src/compiler/mapper/integer_unbound_multiplier.h
@@ -7,15 +7,14 @@ class IntegerUnboundMultiplier final
       : sourcemeta::blaze::SchemaTransformRule{"integer_unbound_multiplier",
                                                ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_upper_bound.h b/src/compiler/mapper/integer_upper_bound.h
index 60969dc4..c6b4009d 100644
--- a/src/compiler/mapper/integer_upper_bound.h
+++ b/src/compiler/mapper/integer_upper_bound.h
@@ -5,15 +5,14 @@ class IntegerUpperBound final : public sourcemeta::blaze::SchemaTransformRule {
   IntegerUpperBound()
       : sourcemeta::blaze::SchemaTransformRule{"integer_upper_bound", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/integer_upper_bound_multiplier.h b/src/compiler/mapper/integer_upper_bound_multiplier.h
index 7ece146f..404e2b0a 100644
--- a/src/compiler/mapper/integer_upper_bound_multiplier.h
+++ b/src/compiler/mapper/integer_upper_bound_multiplier.h
@@ -7,15 +7,14 @@ class IntegerUpperBoundMultiplier final
       : sourcemeta::blaze::SchemaTransformRule{"integer_upper_bound_multiplier",
                                                ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/src/compiler/mapper/number_arbitrary.h b/src/compiler/mapper/number_arbitrary.h
index c2be25ab..a8137925 100644
--- a/src/compiler/mapper/number_arbitrary.h
+++ b/src/compiler/mapper/number_arbitrary.h
@@ -5,15 +5,14 @@ class NumberArbitrary final : public sourcemeta::blaze::SchemaTransformRule {
   NumberArbitrary()
       : sourcemeta::blaze::SchemaTransformRule{"number_arbitrary", ""} {};
 
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &schema,
-            [[maybe_unused]] const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
-            [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver,
-            [[maybe_unused]] const bool is_metaschema) const
+  [[nodiscard]] auto condition(
+      const sourcemeta::core::JSON &schema,
+      [[maybe_unused]] const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      [[maybe_unused]] const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      [[maybe_unused]] const sourcemeta::core::SchemaWalker &walker,
+      [[maybe_unused]] const sourcemeta::core::SchemaResolver &resolver) const
       -> sourcemeta::blaze::SchemaTransformRule::Result override {
     return location.dialect == "https://json-schema.org/draft/2020-12/schema" &&
            vocabularies.contains(sourcemeta::core::SchemaVocabularies::Known::
diff --git a/vendor/blaze/CMakeLists.txt b/vendor/blaze/CMakeLists.txt
index 3e5a8b1a..d0e6be38 100644
--- a/vendor/blaze/CMakeLists.txt
+++ b/vendor/blaze/CMakeLists.txt
@@ -13,6 +13,7 @@ option(BLAZE_CONFIGURATION "Build the Blaze configuration file library" ON)
 option(BLAZE_ALTERSCHEMA "Build the Blaze alterschema rule library" ON)
 option(BLAZE_CODEGEN "Build the Blaze codegen library" ON)
 option(BLAZE_CANONICALIZER "Build the Blaze canonicalizer library" ON)
+option(BLAZE_CONVERT "Build the Blaze convert library" ON)
 option(BLAZE_EDITOR "Build the Blaze editor schema compatibility library" ON)
 option(BLAZE_BUNDLE "Build the Blaze bundle library" ON)
 option(BLAZE_FORMAT "Build the Blaze format library" ON)
@@ -95,6 +96,10 @@ if(BLAZE_CANONICALIZER)
   add_subdirectory(src/canonicalizer)
 endif()
 
+if(BLAZE_CONVERT)
+  add_subdirectory(src/convert)
+endif()
+
 if(BLAZE_EDITOR)
   add_subdirectory(src/editor)
 endif()
@@ -185,6 +190,10 @@ if(BLAZE_TESTS)
     add_subdirectory(test/canonicalizer)
   endif()
 
+  if(BLAZE_CONVERT)
+    add_subdirectory(test/convert)
+  endif()
+
   if(BLAZE_EDITOR)
     add_subdirectory(test/editor)
   endif()
diff --git a/vendor/blaze/DEPENDENCIES b/vendor/blaze/DEPENDENCIES
index 5bcbed29..5e63aabc 100644
--- a/vendor/blaze/DEPENDENCIES
+++ b/vendor/blaze/DEPENDENCIES
@@ -1,3 +1,3 @@
 vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
-core https://github.com/sourcemeta/core 4b948ea794732147e017281c523c1b6f934c8174
+core https://github.com/sourcemeta/core 5dabb7f983b54e302b35ab74547b58c86576537b
 jsonschema-test-suite https://github.com/json-schema-org/JSON-Schema-Test-Suite 6648e8194c69697b2e1a15fe76a06a480b183a51
diff --git a/vendor/blaze/config.cmake.in b/vendor/blaze/config.cmake.in
index 98cfeb55..3b3d6aeb 100644
--- a/vendor/blaze/config.cmake.in
+++ b/vendor/blaze/config.cmake.in
@@ -12,6 +12,7 @@ if(NOT BLAZE_COMPONENTS)
   list(APPEND BLAZE_COMPONENTS alterschema)
   list(APPEND BLAZE_COMPONENTS codegen)
   list(APPEND BLAZE_COMPONENTS canonicalizer)
+  list(APPEND BLAZE_COMPONENTS convert)
   list(APPEND BLAZE_COMPONENTS editor)
   list(APPEND BLAZE_COMPONENTS bundle)
   list(APPEND BLAZE_COMPONENTS format)
@@ -55,6 +56,8 @@ foreach(component ${BLAZE_COMPONENTS})
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_codegen.cmake")
   elseif(component STREQUAL "canonicalizer")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_canonicalizer.cmake")
+  elseif(component STREQUAL "convert")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_convert.cmake")
   elseif(component STREQUAL "editor")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_blaze_editor.cmake")
   elseif(component STREQUAL "bundle")
diff --git a/vendor/blaze/ports/javascript/index.mjs b/vendor/blaze/ports/javascript/index.mjs
index bd76d551..3a1d47e4 100644
--- a/vendor/blaze/ports/javascript/index.mjs
+++ b/vendor/blaze/ports/javascript/index.mjs
@@ -323,8 +323,9 @@ function compileInstructionToCode(instruction, captures, visited, budget) {
     case 68: { var r=R('t'); if(!r)return null; if(!children||children.length===0)return r+'return true;'; return r+TO+'return true;for(var k in t){'+lb(children,'t[k]')+'}return true;'; }
     case 69: return fb(69); case 70: return fb(70); case 71: return fb(71); case 72: return fb(72); case 73: return fb(73);
     case 74: return fb(74); case 75: return fb(75); case 76: return fb(76);
-    case 77: { var r=R('t'); return r?r+TO+'return true;for(var k in t){if(_es(t[k])!=='+value+')return false;}return true;':null; }
-    case 78: return fb(78); case 79: return fb(79); case 80: return fb(80); case 81: return fb(81);
+    case 77: return fb(77);
+    case 78: { var r=R('t'); return r?r+TO+'return true;for(var k in t){if(_es(t[k])!=='+value+')return false;}return true;':null; }
+    case 79: return fb(79); case 80: return fb(80); case 81: return fb(81);
     case 82: return fb(82);
     case 83: { var r=R('t'); if(!r)return null; if(!children||children.length===0)return r+'return true;'; return r+'if(!Array.isArray(t))return true;for(var j=0;j<t.length;j++){'+lb(children,'t[j]')+'}return true;'; }
     case 84: { var r=R('t'); if(!r)return null; if(!children||children.length===0)return r+'return true;'; return r+'if(!Array.isArray(t)||'+value+'>=t.length)return true;for(var j='+value+';j<t.length;j++){'+lb(children,'t[j]')+'}return true;'; }
diff --git a/vendor/blaze/src/alterschema/CMakeLists.txt b/vendor/blaze/src/alterschema/CMakeLists.txt
index c0f017b8..055dcf51 100644
--- a/vendor/blaze/src/alterschema/CMakeLists.txt
+++ b/vendor/blaze/src/alterschema/CMakeLists.txt
@@ -116,6 +116,8 @@ target_link_libraries(sourcemeta_blaze_alterschema PUBLIC
   sourcemeta::core::jsonschema)
 target_link_libraries(sourcemeta_blaze_alterschema PUBLIC
   sourcemeta::blaze::compiler)
+target_link_libraries(sourcemeta_blaze_alterschema PRIVATE
+  sourcemeta::blaze::bundle)
 target_link_libraries(sourcemeta_blaze_alterschema PRIVATE
   sourcemeta::blaze::evaluator)
 target_link_libraries(sourcemeta_blaze_alterschema PRIVATE
diff --git a/vendor/blaze/src/alterschema/alterschema.cc b/vendor/blaze/src/alterschema/alterschema.cc
index b3195ed2..289137da 100644
--- a/vendor/blaze/src/alterschema/alterschema.cc
+++ b/vendor/blaze/src/alterschema/alterschema.cc
@@ -1,4 +1,5 @@
 #include <sourcemeta/blaze/alterschema.h>
+#include <sourcemeta/blaze/bundle.h>
 #include <sourcemeta/blaze/compiler.h>
 #include <sourcemeta/blaze/evaluator.h>
 #include <sourcemeta/blaze/output.h>
@@ -15,10 +16,11 @@
 #include <cassert>       // assert
 #include <cmath>         // std::floor, std::ceil, std::isfinite
 #include <cstddef>       // std::size_t
-#include <functional>    // std::ref
+#include <functional>    // std::ref, std::reference_wrapper
 #include <iterator>      // std::back_inserter
 #include <limits>        // std::numeric_limits
 #include <memory>        // std::unique_ptr, std::make_unique
+#include <optional>      // std::optional
 #include <sstream>       // std::ostringstream
 #include <string_view>   // std::string_view
 #include <unordered_map> // std::unordered_map
@@ -135,6 +137,131 @@ auto walk_up_in_place_applicators(const JSON &root, const SchemaFrame &frame,
                  is_in_place_applicator, matches);
 }
 
+// Compile a subschema of a wrapper document, whose frame locates schemas
+// within it rather than one at its top. Every schema that the frame locates is
+// bundled into a copy of the document at once, so that the subschema may
+// reference any of them as well as a remote schema
+inline auto compile_embedded_subschema(const JSON &root,
+                                       const SchemaFrame &frame,
+                                       const SchemaFrame::Location &location,
+                                       const SchemaWalker &walker,
+                                       const SchemaResolver &resolver,
+                                       const Compiler &compiler) -> Template {
+  std::unordered_set<Pointer, Pointer::Hasher> roots;
+  std::string_view default_dialect{location.dialect};
+  std::string_view default_base;
+  frame.for_each_subschema([&](const SchemaFrame::Location &entry) -> void {
+    if (entry.parent.has_value()) {
+      return;
+    }
+
+    const auto [iterator, inserted] = roots.insert(to_pointer(entry.pointer));
+    if (!inserted) {
+      return;
+    }
+
+    // A schema that declares no dialect of its own reports the default one
+    // that the document was framed with
+    if (declared_dialect(get(root, *iterator)).empty()) {
+      default_dialect = entry.dialect;
+    }
+
+    // A schema that declares no identifier of its own is addressed from the
+    // top of the document, by the base that the document was framed with
+    if (entry.relative_pointer == 0) {
+      default_base = entry.base;
+    }
+  });
+
+  SchemaFrame::Paths paths;
+  paths.reserve(roots.size());
+  for (const auto &pointer : roots) {
+    paths.push_back(to_weak_pointer(pointer));
+  }
+
+  // A wrapper document may declare a member of this name of its own, so bundle
+  // into one that it does not declare, which then only holds what bundling
+  // embedded
+  JSON::String container_name{"x-sourcemeta-embedded"};
+  while (root.defines(container_name)) {
+    container_name.push_back('_');
+  }
+
+  const Pointer container{container_name};
+  auto document{root};
+  bundle(document, walker, resolver, BundleMode::References, default_dialect,
+         "", container, paths, default_base);
+
+  // Bundling embeds every remote schema into the container, outside of every
+  // schema that the frame located, so each of them is framed as a schema too
+  std::vector<Pointer> embedded;
+  const auto *remotes{document.try_at(container_name)};
+  if (remotes != nullptr) {
+    embedded.reserve(remotes->size());
+    for (const auto &entry : remotes->as_object()) {
+      embedded.push_back(container.concat(Pointer{entry.first}));
+    }
+  }
+
+  for (const auto &pointer : embedded) {
+    paths.push_back(to_weak_pointer(pointer));
+  }
+
+  const SchemaFrame bundled_frame{SchemaFrame::Mode::References,
+                                  document,
+                                  walker,
+                                  resolver,
+                                  default_dialect,
+                                  "",
+                                  SchemaFrame::IdentifierMode::Additional,
+                                  paths,
+                                  default_base};
+  const auto entrypoint{bundled_frame.uri(location.pointer)};
+  assert(entrypoint.has_value());
+  return compile(document, walker, resolver, compiler, bundled_frame,
+                 entrypoint.value().get(), Mode::Exhaustive);
+}
+
+// Compile the subschema at a location of a frame that does not stand alone,
+// setting the base that evaluate paths are relative to, or report nothing if
+// it does not compile
+inline auto compile_non_standalone_subschema(
+    const JSON &root, const SchemaFrame &frame,
+    const SchemaFrame::Location &location, const SchemaWalker &walker,
+    const SchemaResolver &resolver, const Compiler &compiler, WeakPointer &base)
+    -> std::optional<Template> {
+  // A frame that locates schemas within a wrapper document has no schema at
+  // the top of that document to wrap
+  const auto embedded{!frame.traverse(EMPTY_WEAK_POINTER).has_value()};
+  std::optional<JSON> subschema;
+  std::string_view default_id;
+  if (!embedded) {
+    // Deliberately framed without a default identifier, so that the root
+    // comes back empty exactly when the schema declares none of its own
+    const SchemaFrame declared_frame{SchemaFrame::Mode::Root, root, walker,
+                                     resolver, location.dialect};
+    default_id = location.base;
+    if (!declared_frame.root().empty() || default_id.empty()) {
+      default_id = "";
+    }
+
+    subschema.emplace(wrap(root, frame, location, walker, resolver, base));
+  }
+
+  try {
+    return embedded ? compile_embedded_subschema(root, frame, location, walker,
+                                                 resolver, compiler)
+                    : compile(subschema.value(), walker, resolver, compiler,
+                              Mode::Exhaustive, location.dialect, default_id);
+  } catch (const CompilerReferenceTargetNotSchemaError &) {
+    throw;
+  } catch (const SchemaVocabularyError &) {
+    throw;
+  } catch (...) {
+    return std::nullopt;
+  }
+}
+
 #define ONLY_CONTINUE_IF(condition)                                            \
   if (!(condition)) {                                                          \
     return false;                                                              \
@@ -247,70 +374,12 @@ auto walk_up_in_place_applicators(const JSON &root, const SchemaFrame &frame,
 #include "linter/valid_default.h"
 #include "linter/valid_examples.h"
 
-// Upgrade
-#include "upgrade/helpers.h"
-#include "upgrade/prefix_promoted_2020_12_keywords.h"
-#include "upgrade/prefix_promoted_draft_2019_09_keywords.h"
-#include "upgrade/prefix_promoted_draft_4_keywords.h"
-#include "upgrade/prefix_promoted_draft_6_keywords.h"
-#include "upgrade/prefix_promoted_draft_7_keywords.h"
-#include "upgrade/upgrade_2019_09_to_2020_12.h"
-#include "upgrade/upgrade_dialect_override_cleanup.h"
-#include "upgrade/upgrade_draft_3_to_draft_4.h"
-#include "upgrade/upgrade_draft_4_to_draft_6.h"
-#include "upgrade/upgrade_draft_6_to_draft_7.h"
-#include "upgrade/upgrade_draft_7_to_draft_2019_09.h"
-
 #undef ONLY_CONTINUE_IF
 } // namespace sourcemeta::blaze
 
 namespace sourcemeta::blaze {
 
 auto add(SchemaTransformer &bundle, const AlterSchemaMode mode) -> void {
-  if (mode == AlterSchemaMode::UpgradeDraft4 ||
-      mode == AlterSchemaMode::UpgradeDraft6 ||
-      mode == AlterSchemaMode::UpgradeDraft7 ||
-      mode == AlterSchemaMode::Upgrade201909 ||
-      mode == AlterSchemaMode::Upgrade202012) {
-    bundle.add<DraftOfficialDialectWithHttps>();
-    bundle.add<DraftOfficialDialectWithoutEmptyFragment>();
-    bundle.add<PrefixPromotedDraft4Keywords>();
-    bundle.add<UpgradeDraft3ToDraft4>();
-
-    if (mode == AlterSchemaMode::UpgradeDraft6 ||
-        mode == AlterSchemaMode::UpgradeDraft7 ||
-        mode == AlterSchemaMode::Upgrade201909 ||
-        mode == AlterSchemaMode::Upgrade202012) {
-      bundle.add<PrefixPromotedDraft6Keywords>();
-      bundle.add<UpgradeDraft4ToDraft6>();
-      bundle.add<EmptyObjectAsTrue>();
-    }
-
-    if (mode == AlterSchemaMode::UpgradeDraft7 ||
-        mode == AlterSchemaMode::Upgrade201909 ||
-        mode == AlterSchemaMode::Upgrade202012) {
-      bundle.add<PrefixPromotedDraft7Keywords>();
-      bundle.add<UpgradeDraft6ToDraft7>();
-      bundle.add<EnumToConst>();
-    }
-
-    if (mode == AlterSchemaMode::Upgrade201909 ||
-        mode == AlterSchemaMode::Upgrade202012) {
-      bundle.add<PrefixPromoted201909Keywords>();
-      bundle.add<UpgradeDraft7To201909>();
-      bundle.add<DefinitionsToDefs>();
-    }
-
-    if (mode == AlterSchemaMode::Upgrade202012) {
-      bundle.add<PrefixPromoted202012Keywords>();
-      bundle.add<Upgrade201909To202012>();
-    }
-
-    bundle.add<UpgradeDialectOverrideCleanup>();
-
-    return;
-  }
-
   if (mode == AlterSchemaMode::Linter) {
     bundle.add<DefinitionsToDefs>();
   }
diff --git a/vendor/blaze/src/alterschema/common/allof_false_simplify.h b/vendor/blaze/src/alterschema/common/allof_false_simplify.h
index 01e1622f..7bd4e2e5 100644
--- a/vendor/blaze/src/alterschema/common/allof_false_simplify.h
+++ b/vendor/blaze/src/alterschema/common/allof_false_simplify.h
@@ -14,7 +14,7 @@ class AllOfFalseSimplify final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"allOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/anyof_false_simplify.h b/vendor/blaze/src/alterschema/common/anyof_false_simplify.h
index 89aada7d..3199c8b5 100644
--- a/vendor/blaze/src/alterschema/common/anyof_false_simplify.h
+++ b/vendor/blaze/src/alterschema/common/anyof_false_simplify.h
@@ -14,7 +14,7 @@ class AnyOfFalseSimplify final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"anyOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/anyof_remove_false_schemas.h b/vendor/blaze/src/alterschema/common/anyof_remove_false_schemas.h
index 88bd636f..9343e033 100644
--- a/vendor/blaze/src/alterschema/common/anyof_remove_false_schemas.h
+++ b/vendor/blaze/src/alterschema/common/anyof_remove_false_schemas.h
@@ -15,7 +15,7 @@ class AnyOfRemoveFalseSchemas final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"anyOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/anyof_true_simplify.h b/vendor/blaze/src/alterschema/common/anyof_true_simplify.h
index 19b65553..ddf027bd 100644
--- a/vendor/blaze/src/alterschema/common/anyof_true_simplify.h
+++ b/vendor/blaze/src/alterschema/common/anyof_true_simplify.h
@@ -14,7 +14,7 @@ class AnyOfTrueSimplify final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"anyOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/const_in_enum.h b/vendor/blaze/src/alterschema/common/const_in_enum.h
index 9733e9e0..c56010f0 100644
--- a/vendor/blaze/src/alterschema/common/const_in_enum.h
+++ b/vendor/blaze/src/alterschema/common/const_in_enum.h
@@ -15,7 +15,7 @@ class ConstInEnum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/const_with_type.h b/vendor/blaze/src/alterschema/common/const_with_type.h
index 09ee2918..0a1442d8 100644
--- a/vendor/blaze/src/alterschema/common/const_with_type.h
+++ b/vendor/blaze/src/alterschema/common/const_with_type.h
@@ -15,7 +15,7 @@ class ConstWithType final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/content_media_type_without_encoding.h b/vendor/blaze/src/alterschema/common/content_media_type_without_encoding.h
index 78b0d023..5351d391 100644
--- a/vendor/blaze/src/alterschema/common/content_media_type_without_encoding.h
+++ b/vendor/blaze/src/alterschema/common/content_media_type_without_encoding.h
@@ -15,7 +15,7 @@ class ContentMediaTypeWithoutEncoding final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/content_schema_without_media_type.h b/vendor/blaze/src/alterschema/common/content_schema_without_media_type.h
index 6eb06714..12ac0523 100644
--- a/vendor/blaze/src/alterschema/common/content_schema_without_media_type.h
+++ b/vendor/blaze/src/alterschema/common/content_schema_without_media_type.h
@@ -19,7 +19,7 @@ class ContentSchemaWithoutMediaType final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/dependencies_property_tautology.h b/vendor/blaze/src/alterschema/common/dependencies_property_tautology.h
index 32e930af..bb56d6e1 100644
--- a/vendor/blaze/src/alterschema/common/dependencies_property_tautology.h
+++ b/vendor/blaze/src/alterschema/common/dependencies_property_tautology.h
@@ -16,7 +16,7 @@ class DependenciesPropertyTautology final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/dependent_required_tautology.h b/vendor/blaze/src/alterschema/common/dependent_required_tautology.h
index 4be92c02..7c954742 100644
--- a/vendor/blaze/src/alterschema/common/dependent_required_tautology.h
+++ b/vendor/blaze/src/alterschema/common/dependent_required_tautology.h
@@ -16,7 +16,7 @@ class DependentRequiredTautology final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/disallow_narrows_type.h b/vendor/blaze/src/alterschema/common/disallow_narrows_type.h
index c214528e..4181d7ce 100644
--- a/vendor/blaze/src/alterschema/common/disallow_narrows_type.h
+++ b/vendor/blaze/src/alterschema/common/disallow_narrows_type.h
@@ -16,7 +16,7 @@ class DisallowNarrowsType final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"disallow"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/double_negation_elimination.h b/vendor/blaze/src/alterschema/common/double_negation_elimination.h
index 09b1a4f1..93d27522 100644
--- a/vendor/blaze/src/alterschema/common/double_negation_elimination.h
+++ b/vendor/blaze/src/alterschema/common/double_negation_elimination.h
@@ -15,7 +15,7 @@ class DoubleNegationElimination final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"not"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/draft_official_dialect_with_https.h b/vendor/blaze/src/alterschema/common/draft_official_dialect_with_https.h
index 014a99b5..d41cc344 100644
--- a/vendor/blaze/src/alterschema/common/draft_official_dialect_with_https.h
+++ b/vendor/blaze/src/alterschema/common/draft_official_dialect_with_https.h
@@ -15,7 +15,7 @@ class DraftOfficialDialectWithHttps final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     using sourcemeta::core::SchemaBaseDialect;
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/draft_official_dialect_without_empty_fragment.h b/vendor/blaze/src/alterschema/common/draft_official_dialect_without_empty_fragment.h
index 2451b9d6..80308d32 100644
--- a/vendor/blaze/src/alterschema/common/draft_official_dialect_without_empty_fragment.h
+++ b/vendor/blaze/src/alterschema/common/draft_official_dialect_without_empty_fragment.h
@@ -14,8 +14,7 @@ class DraftOfficialDialectWithoutEmptyFragment final
                                const sourcemeta::core::SchemaFrame &,
                                const sourcemeta::core::SchemaFrame::Location &,
                                const sourcemeta::core::SchemaWalker &,
-                               const sourcemeta::core::SchemaResolver &,
-                               const bool) const
+                               const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object());
     const auto *schema_keyword{schema.try_at("$schema")};
diff --git a/vendor/blaze/src/alterschema/common/draft_ref_siblings.h b/vendor/blaze/src/alterschema/common/draft_ref_siblings.h
index 0e9d3bc4..4fc78aba 100644
--- a/vendor/blaze/src/alterschema/common/draft_ref_siblings.h
+++ b/vendor/blaze/src/alterschema/common/draft_ref_siblings.h
@@ -14,7 +14,7 @@ class DraftRefSiblings final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_7,
diff --git a/vendor/blaze/src/alterschema/common/drop_allof_empty_schemas.h b/vendor/blaze/src/alterschema/common/drop_allof_empty_schemas.h
index c06df01d..e5ffcf34 100644
--- a/vendor/blaze/src/alterschema/common/drop_allof_empty_schemas.h
+++ b/vendor/blaze/src/alterschema/common/drop_allof_empty_schemas.h
@@ -7,12 +7,10 @@ class DropAllOfEmptySchemas final : public SchemaTransformRule {
                             "Empty schemas in `allOf` are redundant and can be "
                             "removed"} {};
 
-  [[nodiscard]] auto
-  condition(const JSON &schema, const JSON &,
-            const SchemaVocabularies &vocabularies, const SchemaFrame &,
-            const SchemaFrame::Location &, const SchemaWalker &,
-            const SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+  [[nodiscard]] auto condition(
+      const JSON &schema, const JSON &, const SchemaVocabularies &vocabularies,
+      const SchemaFrame &, const SchemaFrame::Location &, const SchemaWalker &,
+      const SchemaResolver &) const -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_APPLICATOR,
          SchemaVocabularies::Known::JSON_SCHEMA_2019_09_APPLICATOR,
diff --git a/vendor/blaze/src/alterschema/common/drop_extends_empty_schemas.h b/vendor/blaze/src/alterschema/common/drop_extends_empty_schemas.h
index 9a6f501d..59a8505e 100644
--- a/vendor/blaze/src/alterschema/common/drop_extends_empty_schemas.h
+++ b/vendor/blaze/src/alterschema/common/drop_extends_empty_schemas.h
@@ -14,7 +14,7 @@ class DropExtendsEmptySchemas final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"extends"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/duplicate_allof_branches.h b/vendor/blaze/src/alterschema/common/duplicate_allof_branches.h
index 762979ee..7d483349 100644
--- a/vendor/blaze/src/alterschema/common/duplicate_allof_branches.h
+++ b/vendor/blaze/src/alterschema/common/duplicate_allof_branches.h
@@ -17,7 +17,7 @@ class DuplicateAllOfBranches final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/duplicate_anyof_branches.h b/vendor/blaze/src/alterschema/common/duplicate_anyof_branches.h
index c9fffca2..c66e5133 100644
--- a/vendor/blaze/src/alterschema/common/duplicate_anyof_branches.h
+++ b/vendor/blaze/src/alterschema/common/duplicate_anyof_branches.h
@@ -17,7 +17,7 @@ class DuplicateAnyOfBranches final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/duplicate_enum_values.h b/vendor/blaze/src/alterschema/common/duplicate_enum_values.h
index 3103a4c5..21907b0b 100644
--- a/vendor/blaze/src/alterschema/common/duplicate_enum_values.h
+++ b/vendor/blaze/src/alterschema/common/duplicate_enum_values.h
@@ -14,7 +14,7 @@ class DuplicateEnumValues final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/duplicate_required_values.h b/vendor/blaze/src/alterschema/common/duplicate_required_values.h
index 1532b309..b4b91d73 100644
--- a/vendor/blaze/src/alterschema/common/duplicate_required_values.h
+++ b/vendor/blaze/src/alterschema/common/duplicate_required_values.h
@@ -15,7 +15,7 @@ class DuplicateRequiredValues final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/dynamic_ref_to_static_ref.h b/vendor/blaze/src/alterschema/common/dynamic_ref_to_static_ref.h
index 6ba20546..a5ec6f3c 100644
--- a/vendor/blaze/src/alterschema/common/dynamic_ref_to_static_ref.h
+++ b/vendor/blaze/src/alterschema/common/dynamic_ref_to_static_ref.h
@@ -21,7 +21,7 @@ class DynamicRefToStaticRef final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object() && !schema.defines("$ref"));
 
diff --git a/vendor/blaze/src/alterschema/common/else_without_if.h b/vendor/blaze/src/alterschema/common/else_without_if.h
index 4284a730..6d9de6c9 100644
--- a/vendor/blaze/src/alterschema/common/else_without_if.h
+++ b/vendor/blaze/src/alterschema/common/else_without_if.h
@@ -18,7 +18,7 @@ class ElseWithoutIf final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/empty_object_as_true.h b/vendor/blaze/src/alterschema/common/empty_object_as_true.h
index fa04952f..32c89159 100644
--- a/vendor/blaze/src/alterschema/common/empty_object_as_true.h
+++ b/vendor/blaze/src/alterschema/common/empty_object_as_true.h
@@ -15,7 +15,7 @@ class EmptyObjectAsTrue final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
                          {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_CORE,
diff --git a/vendor/blaze/src/alterschema/common/enum_with_type.h b/vendor/blaze/src/alterschema/common/enum_with_type.h
index aa700c98..f381f0cf 100644
--- a/vendor/blaze/src/alterschema/common/enum_with_type.h
+++ b/vendor/blaze/src/alterschema/common/enum_with_type.h
@@ -15,7 +15,7 @@ class EnumWithType final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_VALIDATION,
diff --git a/vendor/blaze/src/alterschema/common/equal_numeric_bounds_to_enum.h b/vendor/blaze/src/alterschema/common/equal_numeric_bounds_to_enum.h
index 04d3b912..50224471 100644
--- a/vendor/blaze/src/alterschema/common/equal_numeric_bounds_to_enum.h
+++ b/vendor/blaze/src/alterschema/common/equal_numeric_bounds_to_enum.h
@@ -15,7 +15,7 @@ class EqualNumericBoundsToEnum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
                          {SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_4,
diff --git a/vendor/blaze/src/alterschema/common/exclusive_bounds_false_drop.h b/vendor/blaze/src/alterschema/common/exclusive_bounds_false_drop.h
index 7cb5fc07..04c0c12b 100644
--- a/vendor/blaze/src/alterschema/common/exclusive_bounds_false_drop.h
+++ b/vendor/blaze/src/alterschema/common/exclusive_bounds_false_drop.h
@@ -15,7 +15,7 @@ class ExclusiveBoundsFalseDrop final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
                          {SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_3,
diff --git a/vendor/blaze/src/alterschema/common/exclusive_maximum_number_and_maximum.h b/vendor/blaze/src/alterschema/common/exclusive_maximum_number_and_maximum.h
index cfc77385..e209f9d4 100644
--- a/vendor/blaze/src/alterschema/common/exclusive_maximum_number_and_maximum.h
+++ b/vendor/blaze/src/alterschema/common/exclusive_maximum_number_and_maximum.h
@@ -15,7 +15,7 @@ class ExclusiveMaximumNumberAndMaximum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/exclusive_minimum_number_and_minimum.h b/vendor/blaze/src/alterschema/common/exclusive_minimum_number_and_minimum.h
index ecc40904..003d269a 100644
--- a/vendor/blaze/src/alterschema/common/exclusive_minimum_number_and_minimum.h
+++ b/vendor/blaze/src/alterschema/common/exclusive_minimum_number_and_minimum.h
@@ -15,7 +15,7 @@ class ExclusiveMinimumNumberAndMinimum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/flatten_nested_allof.h b/vendor/blaze/src/alterschema/common/flatten_nested_allof.h
index 2a2fd588..03d644f5 100644
--- a/vendor/blaze/src/alterschema/common/flatten_nested_allof.h
+++ b/vendor/blaze/src/alterschema/common/flatten_nested_allof.h
@@ -15,7 +15,7 @@ class FlattenNestedAllOf final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"allOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/flatten_nested_anyof.h b/vendor/blaze/src/alterschema/common/flatten_nested_anyof.h
index 1ccb4ef8..da7cf45a 100644
--- a/vendor/blaze/src/alterschema/common/flatten_nested_anyof.h
+++ b/vendor/blaze/src/alterschema/common/flatten_nested_anyof.h
@@ -15,7 +15,7 @@ class FlattenNestedAnyOf final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"anyOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/flatten_nested_extends.h b/vendor/blaze/src/alterschema/common/flatten_nested_extends.h
index 07de5bbb..3a255546 100644
--- a/vendor/blaze/src/alterschema/common/flatten_nested_extends.h
+++ b/vendor/blaze/src/alterschema/common/flatten_nested_extends.h
@@ -15,7 +15,7 @@ class FlattenNestedExtends final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"extends"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/if_without_then_else.h b/vendor/blaze/src/alterschema/common/if_without_then_else.h
index 321051e7..def63905 100644
--- a/vendor/blaze/src/alterschema/common/if_without_then_else.h
+++ b/vendor/blaze/src/alterschema/common/if_without_then_else.h
@@ -19,7 +19,7 @@ class IfWithoutThenElse final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/ignored_metaschema.h b/vendor/blaze/src/alterschema/common/ignored_metaschema.h
index bdc779cc..3a10a8c1 100644
--- a/vendor/blaze/src/alterschema/common/ignored_metaschema.h
+++ b/vendor/blaze/src/alterschema/common/ignored_metaschema.h
@@ -15,7 +15,7 @@ class IgnoredMetaschema final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object());
     const auto *schema_keyword{schema.try_at("$schema")};
diff --git a/vendor/blaze/src/alterschema/common/max_contains_without_contains.h b/vendor/blaze/src/alterschema/common/max_contains_without_contains.h
index b3038540..a66afd4c 100644
--- a/vendor/blaze/src/alterschema/common/max_contains_without_contains.h
+++ b/vendor/blaze/src/alterschema/common/max_contains_without_contains.h
@@ -15,7 +15,7 @@ class MaxContainsWithoutContains final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/maximum_real_for_integer.h b/vendor/blaze/src/alterschema/common/maximum_real_for_integer.h
index 91381b1e..7cf8ee1e 100644
--- a/vendor/blaze/src/alterschema/common/maximum_real_for_integer.h
+++ b/vendor/blaze/src/alterschema/common/maximum_real_for_integer.h
@@ -15,7 +15,7 @@ class MaximumRealForInteger final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/min_contains_without_contains.h b/vendor/blaze/src/alterschema/common/min_contains_without_contains.h
index be7f1ad6..229f1715 100644
--- a/vendor/blaze/src/alterschema/common/min_contains_without_contains.h
+++ b/vendor/blaze/src/alterschema/common/min_contains_without_contains.h
@@ -15,7 +15,7 @@ class MinContainsWithoutContains final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/minimum_real_for_integer.h b/vendor/blaze/src/alterschema/common/minimum_real_for_integer.h
index 31d1be5e..a97722e0 100644
--- a/vendor/blaze/src/alterschema/common/minimum_real_for_integer.h
+++ b/vendor/blaze/src/alterschema/common/minimum_real_for_integer.h
@@ -15,7 +15,7 @@ class MinimumRealForInteger final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/modern_official_dialect_with_empty_fragment.h b/vendor/blaze/src/alterschema/common/modern_official_dialect_with_empty_fragment.h
index 862c513b..91238dd1 100644
--- a/vendor/blaze/src/alterschema/common/modern_official_dialect_with_empty_fragment.h
+++ b/vendor/blaze/src/alterschema/common/modern_official_dialect_with_empty_fragment.h
@@ -15,8 +15,7 @@ class ModernOfficialDialectWithEmptyFragment final
                                const sourcemeta::core::SchemaFrame &,
                                const sourcemeta::core::SchemaFrame::Location &,
                                const sourcemeta::core::SchemaWalker &,
-                               const sourcemeta::core::SchemaResolver &,
-                               const bool) const
+                               const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object());
     const auto *schema_keyword{schema.try_at("$schema")};
diff --git a/vendor/blaze/src/alterschema/common/modern_official_dialect_with_http.h b/vendor/blaze/src/alterschema/common/modern_official_dialect_with_http.h
index 352cd36b..e76949af 100644
--- a/vendor/blaze/src/alterschema/common/modern_official_dialect_with_http.h
+++ b/vendor/blaze/src/alterschema/common/modern_official_dialect_with_http.h
@@ -15,7 +15,7 @@ class ModernOfficialDialectWithHttp final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     using sourcemeta::core::SchemaBaseDialect;
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/non_applicable_additional_items.h b/vendor/blaze/src/alterschema/common/non_applicable_additional_items.h
index 1b2ee2e4..bf526d75 100644
--- a/vendor/blaze/src/alterschema/common/non_applicable_additional_items.h
+++ b/vendor/blaze/src/alterschema/common/non_applicable_additional_items.h
@@ -19,7 +19,7 @@ class NonApplicableAdditionalItems final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/non_applicable_disallow_types.h b/vendor/blaze/src/alterschema/common/non_applicable_disallow_types.h
index 202a2651..3ac40496 100644
--- a/vendor/blaze/src/alterschema/common/non_applicable_disallow_types.h
+++ b/vendor/blaze/src/alterschema/common/non_applicable_disallow_types.h
@@ -15,7 +15,7 @@ class NonApplicableDisallowTypes final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"disallow"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/non_applicable_enum_validation_keywords.h b/vendor/blaze/src/alterschema/common/non_applicable_enum_validation_keywords.h
index 642b6acb..0a2e048d 100644
--- a/vendor/blaze/src/alterschema/common/non_applicable_enum_validation_keywords.h
+++ b/vendor/blaze/src/alterschema/common/non_applicable_enum_validation_keywords.h
@@ -15,7 +15,7 @@ class NonApplicableEnumValidationKeywords final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/non_applicable_type_specific_keywords.h b/vendor/blaze/src/alterschema/common/non_applicable_type_specific_keywords.h
index fdd34cae..c9d12c90 100644
--- a/vendor/blaze/src/alterschema/common/non_applicable_type_specific_keywords.h
+++ b/vendor/blaze/src/alterschema/common/non_applicable_type_specific_keywords.h
@@ -14,7 +14,7 @@ class NonApplicableTypeSpecificKeywords final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object());
 
diff --git a/vendor/blaze/src/alterschema/common/not_false.h b/vendor/blaze/src/alterschema/common/not_false.h
index 3f94d7bb..c102dff2 100644
--- a/vendor/blaze/src/alterschema/common/not_false.h
+++ b/vendor/blaze/src/alterschema/common/not_false.h
@@ -16,7 +16,7 @@ class NotFalse final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &frame,
             const SchemaFrame::Location &location, const SchemaWalker &,
-            const SchemaResolver &, const bool) const
+            const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/oneof_false_simplify.h b/vendor/blaze/src/alterschema/common/oneof_false_simplify.h
index ad6114dc..27b72030 100644
--- a/vendor/blaze/src/alterschema/common/oneof_false_simplify.h
+++ b/vendor/blaze/src/alterschema/common/oneof_false_simplify.h
@@ -14,7 +14,7 @@ class OneOfFalseSimplify final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"oneOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/oneof_to_anyof_disjoint_types.h b/vendor/blaze/src/alterschema/common/oneof_to_anyof_disjoint_types.h
index 15b6f2d7..e5c1b359 100644
--- a/vendor/blaze/src/alterschema/common/oneof_to_anyof_disjoint_types.h
+++ b/vendor/blaze/src/alterschema/common/oneof_to_anyof_disjoint_types.h
@@ -15,7 +15,7 @@ class OneOfToAnyOfDisjointTypes final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     static const JSON::String KEYWORD{"oneOf"};
     ONLY_CONTINUE_IF(
diff --git a/vendor/blaze/src/alterschema/common/orphan_definitions.h b/vendor/blaze/src/alterschema/common/orphan_definitions.h
index 8fb37d65..f202bf42 100644
--- a/vendor/blaze/src/alterschema/common/orphan_definitions.h
+++ b/vendor/blaze/src/alterschema/common/orphan_definitions.h
@@ -15,7 +15,7 @@ class OrphanDefinitions final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &resolver, const bool) const
+            const sourcemeta::core::SchemaResolver &resolver) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object());
     const bool has_modern_core{
@@ -32,14 +32,24 @@ class OrphanDefinitions final : public SchemaTransformRule {
                                schema.defines("definitions")};
     ONLY_CONTINUE_IF(has_defs || has_definitions);
 
-    const auto base{frame.traverse(frame.root())};
-    ONLY_CONTINUE_IF(base.has_value());
+    // A frame may locate more than one schema within its document, and a
+    // definition is only an orphan if none of them reaches it
+    std::vector<
+        std::reference_wrapper<const sourcemeta::core::SchemaFrame::Location>>
+        roots;
+    frame.for_each_subschema(
+        [&roots](const sourcemeta::core::SchemaFrame::Location &entry) -> void {
+          if (!entry.parent.has_value()) {
+            roots.emplace_back(entry);
+          }
+        });
+    ONLY_CONTINUE_IF(!roots.empty());
 
     std::vector<Pointer> orphans;
-    collect_orphans(frame, base->get(), walker, resolver, location.pointer,
-                    schema, "$defs", has_defs, orphans);
-    collect_orphans(frame, base->get(), walker, resolver, location.pointer,
-                    schema, "definitions", has_definitions, orphans);
+    collect_orphans(frame, roots, walker, resolver, location.pointer, schema,
+                    "$defs", has_defs, orphans);
+    collect_orphans(frame, roots, walker, resolver, location.pointer, schema,
+                    "definitions", has_definitions, orphans);
 
     ONLY_CONTINUE_IF(!orphans.empty());
     return applies_to_pointers(std::move(orphans));
@@ -104,7 +114,8 @@ class OrphanDefinitions final : public SchemaTransformRule {
 
   static auto
   collect_orphans(const sourcemeta::core::SchemaFrame &frame,
-                  const sourcemeta::core::SchemaFrame::Location &base,
+                  const std::vector<std::reference_wrapper<
+                      const sourcemeta::core::SchemaFrame::Location>> &roots,
                   const sourcemeta::core::SchemaWalker &walker,
                   const sourcemeta::core::SchemaResolver &resolver,
                   const WeakPointer &prefix, const JSON &schema,
@@ -122,9 +133,17 @@ class OrphanDefinitions final : public SchemaTransformRule {
           absolute_entry_pointer,
           sourcemeta::core::SchemaFrame::LocationType::Subschema)};
       if (entry_location.has_value() &&
-          !frame.is_reachable(base, entry_location->get(), walker, resolver) &&
-          !has_reachable_reference_through(frame, base, walker, resolver,
-                                           absolute_entry_pointer) &&
+          std::ranges::none_of(
+              roots,
+              [&](const std::reference_wrapper<
+                  const sourcemeta::core::SchemaFrame::Location> &root)
+                  -> bool {
+                return frame.is_reachable(root.get(), entry_location->get(),
+                                          walker, resolver) ||
+                       has_reachable_reference_through(frame, root.get(),
+                                                       walker, resolver,
+                                                       absolute_entry_pointer);
+              }) &&
           !(!frame.standalone() &&
             subtree_has_dynamic_anchor(frame, absolute_entry_pointer))) {
         orphans.push_back(Pointer{container, entry.first});
diff --git a/vendor/blaze/src/alterschema/common/required_properties_in_properties.h b/vendor/blaze/src/alterschema/common/required_properties_in_properties.h
index 023053e1..dd7a3299 100644
--- a/vendor/blaze/src/alterschema/common/required_properties_in_properties.h
+++ b/vendor/blaze/src/alterschema/common/required_properties_in_properties.h
@@ -15,7 +15,7 @@ class RequiredPropertiesInProperties final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &resolver, const bool) const
+            const sourcemeta::core::SchemaResolver &resolver) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         ((vocabularies.contains(
diff --git a/vendor/blaze/src/alterschema/common/single_type_array.h b/vendor/blaze/src/alterschema/common/single_type_array.h
index a3cee0cf..2e952d88 100644
--- a/vendor/blaze/src/alterschema/common/single_type_array.h
+++ b/vendor/blaze/src/alterschema/common/single_type_array.h
@@ -14,7 +14,7 @@ class SingleTypeArray final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/then_without_if.h b/vendor/blaze/src/alterschema/common/then_without_if.h
index ea9c0d8e..49b21f5c 100644
--- a/vendor/blaze/src/alterschema/common/then_without_if.h
+++ b/vendor/blaze/src/alterschema/common/then_without_if.h
@@ -18,7 +18,7 @@ class ThenWithoutIf final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/unknown_keywords_prefix.h b/vendor/blaze/src/alterschema/common/unknown_keywords_prefix.h
index 47862243..fcdb8bac 100644
--- a/vendor/blaze/src/alterschema/common/unknown_keywords_prefix.h
+++ b/vendor/blaze/src/alterschema/common/unknown_keywords_prefix.h
@@ -13,7 +13,7 @@ class UnknownKeywordsPrefix final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &,
             const SchemaFrame::Location &, const SchemaWalker &walker,
-            const SchemaResolver &, const bool) const
+            const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object());
     std::vector<Pointer> locations;
diff --git a/vendor/blaze/src/alterschema/common/unknown_local_ref.h b/vendor/blaze/src/alterschema/common/unknown_local_ref.h
index 399060f6..66a5fa3f 100644
--- a/vendor/blaze/src/alterschema/common/unknown_local_ref.h
+++ b/vendor/blaze/src/alterschema/common/unknown_local_ref.h
@@ -16,7 +16,7 @@ class UnknownLocalRef final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &frame,
             const SchemaFrame::Location &location, const SchemaWalker &,
-            const SchemaResolver &, const bool) const
+            const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_CORE,
diff --git a/vendor/blaze/src/alterschema/common/unnecessary_allof_ref_wrapper_draft.h b/vendor/blaze/src/alterschema/common/unnecessary_allof_ref_wrapper_draft.h
index 6e553cee..a90af79e 100644
--- a/vendor/blaze/src/alterschema/common/unnecessary_allof_ref_wrapper_draft.h
+++ b/vendor/blaze/src/alterschema/common/unnecessary_allof_ref_wrapper_draft.h
@@ -14,7 +14,7 @@ class UnnecessaryAllOfRefWrapperDraft final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_7,
diff --git a/vendor/blaze/src/alterschema/common/unnecessary_extends_ref_wrapper.h b/vendor/blaze/src/alterschema/common/unnecessary_extends_ref_wrapper.h
index a2278e61..a533ce2e 100644
--- a/vendor/blaze/src/alterschema/common/unnecessary_extends_ref_wrapper.h
+++ b/vendor/blaze/src/alterschema/common/unnecessary_extends_ref_wrapper.h
@@ -14,7 +14,7 @@ class UnnecessaryExtendsRefWrapper final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_3,
diff --git a/vendor/blaze/src/alterschema/common/unsatisfiable_drop_validation.h b/vendor/blaze/src/alterschema/common/unsatisfiable_drop_validation.h
index 17a188d6..0fa44de5 100644
--- a/vendor/blaze/src/alterschema/common/unsatisfiable_drop_validation.h
+++ b/vendor/blaze/src/alterschema/common/unsatisfiable_drop_validation.h
@@ -14,7 +14,7 @@ class UnsatisfiableDropValidation final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/common/unsatisfiable_in_place_applicator_type.h b/vendor/blaze/src/alterschema/common/unsatisfiable_in_place_applicator_type.h
index d0df0d29..8f800535 100644
--- a/vendor/blaze/src/alterschema/common/unsatisfiable_in_place_applicator_type.h
+++ b/vendor/blaze/src/alterschema/common/unsatisfiable_in_place_applicator_type.h
@@ -15,7 +15,7 @@ class UnsatisfiableInPlaceApplicatorType final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object() && schema.defines("type"));
     ONLY_CONTINUE_IF(vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema.h b/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema.h
index 31248731..10605ad5 100644
--- a/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema.h
+++ b/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema.h
@@ -40,21 +40,6 @@ enum class AlterSchemaMode : std::uint8_t {
   /// Rules that simplify the given schema for both human readability and
   /// performance
   Linter,
-
-  /// Rules that upgrade a JSON Schema document up to JSON Schema Draft 4
-  UpgradeDraft4,
-
-  /// Rules that upgrade a JSON Schema document up to JSON Schema Draft 6
-  UpgradeDraft6,
-
-  /// Rules that upgrade a JSON Schema document up to JSON Schema Draft 7
-  UpgradeDraft7,
-
-  /// Rules that upgrade a JSON Schema document up to JSON Schema 2019-09
-  Upgrade201909,
-
-  /// Rules that upgrade a JSON Schema document up to JSON Schema 2020-12
-  Upgrade202012,
 };
 
 /// @ingroup alterschema
@@ -124,13 +109,13 @@ class SOURCEMETA_BLAZE_ALTERSCHEMA_EXPORT SchemaRule final
              const std::string_view default_dialect = "",
              const std::optional<Tweaks> &tweaks = std::nullopt,
              const Scope scope = Scope::All);
-  [[nodiscard]] auto
-  condition(const sourcemeta::core::JSON &, const sourcemeta::core::JSON &,
-            const sourcemeta::core::SchemaVocabularies &,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
-            const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+  [[nodiscard]] auto condition(const sourcemeta::core::JSON &,
+                               const sourcemeta::core::JSON &,
+                               const sourcemeta::core::SchemaVocabularies &,
+                               const sourcemeta::core::SchemaFrame &,
+                               const sourcemeta::core::SchemaFrame::Location &,
+                               const sourcemeta::core::SchemaWalker &,
+                               const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override;
 
 private:
diff --git a/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema_transformer.h b/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema_transformer.h
index 9371ab2f..f39db1cb 100644
--- a/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema_transformer.h
+++ b/vendor/blaze/src/alterschema/include/sourcemeta/blaze/alterschema_transformer.h
@@ -95,8 +95,7 @@ class SOURCEMETA_BLAZE_ALTERSCHEMA_EXPORT SchemaTransformRule {
         const sourcemeta::core::SchemaResolver &resolver,
         const sourcemeta::core::SchemaFrame &frame,
         const sourcemeta::core::SchemaFrame::Location &location,
-        const sourcemeta::core::JSON::String &exclude_keyword,
-        const bool is_metaschema) const -> Result;
+        const sourcemeta::core::JSON::String &exclude_keyword) const -> Result;
 
   /// A method to optionally fix any reference location that was affected by the
   /// transformation
@@ -108,15 +107,13 @@ class SOURCEMETA_BLAZE_ALTERSCHEMA_EXPORT SchemaTransformRule {
       -> sourcemeta::core::Pointer;
 
   /// The rule condition
-  [[nodiscard]] virtual auto
-  condition(const sourcemeta::core::JSON &schema,
-            const sourcemeta::core::JSON &root,
-            const sourcemeta::core::SchemaVocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &frame,
-            const sourcemeta::core::SchemaFrame::Location &location,
-            const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &resolver,
-            const bool is_metaschema) const -> Result = 0;
+  [[nodiscard]] virtual auto condition(
+      const sourcemeta::core::JSON &schema, const sourcemeta::core::JSON &root,
+      const sourcemeta::core::SchemaVocabularies &vocabularies,
+      const sourcemeta::core::SchemaFrame &frame,
+      const sourcemeta::core::SchemaFrame::Location &location,
+      const sourcemeta::core::SchemaWalker &walker,
+      const sourcemeta::core::SchemaResolver &resolver) const -> Result = 0;
 
   /// The rule transformation. If this virtual method is not overriden,
   /// then the rule is considered to not mutate the schema
@@ -177,6 +174,12 @@ class SOURCEMETA_BLAZE_ALTERSCHEMA_EXPORT SchemaTransformer {
       const sourcemeta::core::Pointer &, const std::string_view,
       const std::string_view, const SchemaTransformRule::Result &, const bool)>;
 
+  /// Frame a document as it currently stands, in References mode. Applying
+  /// rules calls it again whenever a transformation needs a new frame, so the
+  /// frame it returns only has to remain valid until the next call
+  using Framer = std::function<const sourcemeta::core::SchemaFrame &(
+      const sourcemeta::core::JSON &)>;
+
   /// Apply the bundle of rules to a schema
   [[nodiscard]] auto
   apply(sourcemeta::core::JSON &schema,
@@ -184,8 +187,17 @@ class SOURCEMETA_BLAZE_ALTERSCHEMA_EXPORT SchemaTransformer {
         const sourcemeta::core::SchemaResolver &resolver,
         const Callback &callback, std::string_view default_dialect = "",
         std::string_view default_id = "",
-        const sourcemeta::core::JSON::String &exclude_keyword = "",
-        const bool is_metaschema = false) const
+        const sourcemeta::core::JSON::String &exclude_keyword = "") const
+      -> std::pair<bool, std::uint8_t>;
+
+  /// Apply the bundle of rules to every subschema that a framer locates within
+  /// a document
+  [[nodiscard]] auto
+  apply(sourcemeta::core::JSON &document, const Framer &framer,
+        const sourcemeta::core::SchemaWalker &walker,
+        const sourcemeta::core::SchemaResolver &resolver,
+        const Callback &callback,
+        const sourcemeta::core::JSON::String &exclude_keyword = "") const
       -> std::pair<bool, std::uint8_t>;
 
   /// Report back the rules from the bundle that need to be applied to a
@@ -196,8 +208,18 @@ class SOURCEMETA_BLAZE_ALTERSCHEMA_EXPORT SchemaTransformer {
         const sourcemeta::core::SchemaResolver &resolver,
         const Callback &callback, std::string_view default_dialect = "",
         std::string_view default_id = "",
-        const sourcemeta::core::JSON::String &exclude_keyword = "",
-        const bool is_metaschema = false) const
+        const sourcemeta::core::JSON::String &exclude_keyword = "") const
+      -> std::pair<bool, std::uint8_t>;
+
+  /// Report back the rules from the bundle that need to be applied to every
+  /// subschema that a frame locates within a document
+  [[nodiscard]] auto
+  check(const sourcemeta::core::JSON &document,
+        const sourcemeta::core::SchemaFrame &frame,
+        const sourcemeta::core::SchemaWalker &walker,
+        const sourcemeta::core::SchemaResolver &resolver,
+        const Callback &callback,
+        const sourcemeta::core::JSON::String &exclude_keyword = "") const
       -> std::pair<bool, std::uint8_t>;
 
   [[nodiscard]] auto begin() const -> auto { return this->rules_.cbegin(); }
diff --git a/vendor/blaze/src/alterschema/linter/comment_trim.h b/vendor/blaze/src/alterschema/linter/comment_trim.h
index 2bf82856..e294b868 100644
--- a/vendor/blaze/src/alterschema/linter/comment_trim.h
+++ b/vendor/blaze/src/alterschema/linter/comment_trim.h
@@ -14,7 +14,7 @@ class CommentTrim final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_CORE,
diff --git a/vendor/blaze/src/alterschema/linter/conflicting_readonly_writeonly.h b/vendor/blaze/src/alterschema/linter/conflicting_readonly_writeonly.h
index e9b1952a..976dd3db 100644
--- a/vendor/blaze/src/alterschema/linter/conflicting_readonly_writeonly.h
+++ b/vendor/blaze/src/alterschema/linter/conflicting_readonly_writeonly.h
@@ -14,7 +14,7 @@ class ConflictingReadOnlyWriteOnly final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/const_not_in_enum.h b/vendor/blaze/src/alterschema/linter/const_not_in_enum.h
index f6b204c7..6cbe1afa 100644
--- a/vendor/blaze/src/alterschema/linter/const_not_in_enum.h
+++ b/vendor/blaze/src/alterschema/linter/const_not_in_enum.h
@@ -15,7 +15,7 @@ class ConstNotInEnum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/content_schema_default.h b/vendor/blaze/src/alterschema/linter/content_schema_default.h
index 076dacba..0300b5b6 100644
--- a/vendor/blaze/src/alterschema/linter/content_schema_default.h
+++ b/vendor/blaze/src/alterschema/linter/content_schema_default.h
@@ -19,7 +19,7 @@ class ContentSchemaDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/definitions_to_defs.h b/vendor/blaze/src/alterschema/linter/definitions_to_defs.h
index f66b24da..a41e4e6c 100644
--- a/vendor/blaze/src/alterschema/linter/definitions_to_defs.h
+++ b/vendor/blaze/src/alterschema/linter/definitions_to_defs.h
@@ -14,7 +14,7 @@ class DefinitionsToDefs final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/dependencies_default.h b/vendor/blaze/src/alterschema/linter/dependencies_default.h
index 4ff499f8..3f5932d2 100644
--- a/vendor/blaze/src/alterschema/linter/dependencies_default.h
+++ b/vendor/blaze/src/alterschema/linter/dependencies_default.h
@@ -19,7 +19,7 @@ class DependenciesDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/dependent_required_default.h b/vendor/blaze/src/alterschema/linter/dependent_required_default.h
index 667c566a..2aa22421 100644
--- a/vendor/blaze/src/alterschema/linter/dependent_required_default.h
+++ b/vendor/blaze/src/alterschema/linter/dependent_required_default.h
@@ -15,7 +15,7 @@ class DependentRequiredDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/description_trailing_period.h b/vendor/blaze/src/alterschema/linter/description_trailing_period.h
index 160001cf..35d2c242 100644
--- a/vendor/blaze/src/alterschema/linter/description_trailing_period.h
+++ b/vendor/blaze/src/alterschema/linter/description_trailing_period.h
@@ -15,7 +15,7 @@ class DescriptionTrailingPeriod final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/description_trim.h b/vendor/blaze/src/alterschema/linter/description_trim.h
index 6050908a..825bd8e7 100644
--- a/vendor/blaze/src/alterschema/linter/description_trim.h
+++ b/vendor/blaze/src/alterschema/linter/description_trim.h
@@ -15,7 +15,7 @@ class DescriptionTrim final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/disallow_default.h b/vendor/blaze/src/alterschema/linter/disallow_default.h
index 3cc8b869..3f961bca 100644
--- a/vendor/blaze/src/alterschema/linter/disallow_default.h
+++ b/vendor/blaze/src/alterschema/linter/disallow_default.h
@@ -14,7 +14,7 @@ class DisallowDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/divisible_by_default.h b/vendor/blaze/src/alterschema/linter/divisible_by_default.h
index cfe06384..e78a4a25 100644
--- a/vendor/blaze/src/alterschema/linter/divisible_by_default.h
+++ b/vendor/blaze/src/alterschema/linter/divisible_by_default.h
@@ -15,7 +15,7 @@ class DivisibleByDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/duplicate_examples.h b/vendor/blaze/src/alterschema/linter/duplicate_examples.h
index 83d13248..6ff0326c 100644
--- a/vendor/blaze/src/alterschema/linter/duplicate_examples.h
+++ b/vendor/blaze/src/alterschema/linter/duplicate_examples.h
@@ -14,7 +14,7 @@ class DuplicateExamples final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/else_empty.h b/vendor/blaze/src/alterschema/linter/else_empty.h
index c526071a..36574188 100644
--- a/vendor/blaze/src/alterschema/linter/else_empty.h
+++ b/vendor/blaze/src/alterschema/linter/else_empty.h
@@ -15,7 +15,7 @@ class ElseEmpty final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &frame,
             const SchemaFrame::Location &location, const SchemaWalker &,
-            const SchemaResolver &, const bool) const
+            const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/enum_to_const.h b/vendor/blaze/src/alterschema/linter/enum_to_const.h
index 093632a6..18566263 100644
--- a/vendor/blaze/src/alterschema/linter/enum_to_const.h
+++ b/vendor/blaze/src/alterschema/linter/enum_to_const.h
@@ -14,7 +14,7 @@ class EnumToConst final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/equal_numeric_bounds_to_const.h b/vendor/blaze/src/alterschema/linter/equal_numeric_bounds_to_const.h
index 1373c06f..1d7a0e8d 100644
--- a/vendor/blaze/src/alterschema/linter/equal_numeric_bounds_to_const.h
+++ b/vendor/blaze/src/alterschema/linter/equal_numeric_bounds_to_const.h
@@ -15,7 +15,7 @@ class EqualNumericBoundsToConst final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any({
diff --git a/vendor/blaze/src/alterschema/linter/forbid_empty_enum.h b/vendor/blaze/src/alterschema/linter/forbid_empty_enum.h
index 4b17ec05..21c5f09a 100644
--- a/vendor/blaze/src/alterschema/linter/forbid_empty_enum.h
+++ b/vendor/blaze/src/alterschema/linter/forbid_empty_enum.h
@@ -14,7 +14,7 @@ class ForbidEmptyEnum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/incoherent_min_max_contains.h b/vendor/blaze/src/alterschema/linter/incoherent_min_max_contains.h
index c2e3ebd3..55fc2a6d 100644
--- a/vendor/blaze/src/alterschema/linter/incoherent_min_max_contains.h
+++ b/vendor/blaze/src/alterschema/linter/incoherent_min_max_contains.h
@@ -15,7 +15,7 @@ class IncoherentMinMaxContains final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/invalid_external_ref.h b/vendor/blaze/src/alterschema/linter/invalid_external_ref.h
index 213f84cc..3bbebead 100644
--- a/vendor/blaze/src/alterschema/linter/invalid_external_ref.h
+++ b/vendor/blaze/src/alterschema/linter/invalid_external_ref.h
@@ -12,7 +12,7 @@ class InvalidExternalRef final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &frame,
             const SchemaFrame::Location &location, const SchemaWalker &walker,
-            const SchemaResolver &resolver, const bool) const
+            const SchemaResolver &resolver) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(!frame.standalone());
     ONLY_CONTINUE_IF(vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/items_array_default.h b/vendor/blaze/src/alterschema/linter/items_array_default.h
index 3583dd06..b4de6f1e 100644
--- a/vendor/blaze/src/alterschema/linter/items_array_default.h
+++ b/vendor/blaze/src/alterschema/linter/items_array_default.h
@@ -14,7 +14,7 @@ class ItemsArrayDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/items_schema_default.h b/vendor/blaze/src/alterschema/linter/items_schema_default.h
index 0b813a31..3eeec498 100644
--- a/vendor/blaze/src/alterschema/linter/items_schema_default.h
+++ b/vendor/blaze/src/alterschema/linter/items_schema_default.h
@@ -18,7 +18,7 @@ class ItemsSchemaDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/multiple_of_default.h b/vendor/blaze/src/alterschema/linter/multiple_of_default.h
index 4f98f1a5..f45bb996 100644
--- a/vendor/blaze/src/alterschema/linter/multiple_of_default.h
+++ b/vendor/blaze/src/alterschema/linter/multiple_of_default.h
@@ -14,7 +14,7 @@ class MultipleOfDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/pattern_non_ecma_regex.h b/vendor/blaze/src/alterschema/linter/pattern_non_ecma_regex.h
index cfbf7f4d..7a9a2574 100644
--- a/vendor/blaze/src/alterschema/linter/pattern_non_ecma_regex.h
+++ b/vendor/blaze/src/alterschema/linter/pattern_non_ecma_regex.h
@@ -15,7 +15,7 @@ class PatternNonEcmaRegex final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_VALIDATION,
diff --git a/vendor/blaze/src/alterschema/linter/pattern_properties_default.h b/vendor/blaze/src/alterschema/linter/pattern_properties_default.h
index a250484c..7cbea9d3 100644
--- a/vendor/blaze/src/alterschema/linter/pattern_properties_default.h
+++ b/vendor/blaze/src/alterschema/linter/pattern_properties_default.h
@@ -15,7 +15,7 @@ class PatternPropertiesDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/pattern_properties_non_ecma_regex.h b/vendor/blaze/src/alterschema/linter/pattern_properties_non_ecma_regex.h
index 16c42514..ab283b17 100644
--- a/vendor/blaze/src/alterschema/linter/pattern_properties_non_ecma_regex.h
+++ b/vendor/blaze/src/alterschema/linter/pattern_properties_non_ecma_regex.h
@@ -16,7 +16,7 @@ class PatternPropertiesNonEcmaRegex final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_APPLICATOR,
diff --git a/vendor/blaze/src/alterschema/linter/portable_anchor_names.h b/vendor/blaze/src/alterschema/linter/portable_anchor_names.h
index 3146d208..4dccee0d 100644
--- a/vendor/blaze/src/alterschema/linter/portable_anchor_names.h
+++ b/vendor/blaze/src/alterschema/linter/portable_anchor_names.h
@@ -15,7 +15,7 @@ class PortableAnchorNames final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_CORE,
diff --git a/vendor/blaze/src/alterschema/linter/properties_default.h b/vendor/blaze/src/alterschema/linter/properties_default.h
index 8b94f41f..41f3ee01 100644
--- a/vendor/blaze/src/alterschema/linter/properties_default.h
+++ b/vendor/blaze/src/alterschema/linter/properties_default.h
@@ -15,7 +15,7 @@ class PropertiesDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/property_names_default.h b/vendor/blaze/src/alterschema/linter/property_names_default.h
index 1fc00b4c..f3d0bc37 100644
--- a/vendor/blaze/src/alterschema/linter/property_names_default.h
+++ b/vendor/blaze/src/alterschema/linter/property_names_default.h
@@ -19,7 +19,7 @@ class PropertyNamesDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/property_names_type_default.h b/vendor/blaze/src/alterschema/linter/property_names_type_default.h
index e955ccc4..911ea5c8 100644
--- a/vendor/blaze/src/alterschema/linter/property_names_type_default.h
+++ b/vendor/blaze/src/alterschema/linter/property_names_type_default.h
@@ -15,7 +15,7 @@ class PropertyNamesTypeDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/simple_properties_identifiers.h b/vendor/blaze/src/alterschema/linter/simple_properties_identifiers.h
index 293f2828..e9f9871f 100644
--- a/vendor/blaze/src/alterschema/linter/simple_properties_identifiers.h
+++ b/vendor/blaze/src/alterschema/linter/simple_properties_identifiers.h
@@ -17,7 +17,7 @@ class SimplePropertiesIdentifiers final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_APPLICATOR,
diff --git a/vendor/blaze/src/alterschema/linter/then_empty.h b/vendor/blaze/src/alterschema/linter/then_empty.h
index f477fd4f..d94c1ab7 100644
--- a/vendor/blaze/src/alterschema/linter/then_empty.h
+++ b/vendor/blaze/src/alterschema/linter/then_empty.h
@@ -15,7 +15,7 @@ class ThenEmpty final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &frame,
             const SchemaFrame::Location &location, const SchemaWalker &,
-            const SchemaResolver &, const bool) const
+            const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/title_description_equal.h b/vendor/blaze/src/alterschema/linter/title_description_equal.h
index d894e25c..c0d31369 100644
--- a/vendor/blaze/src/alterschema/linter/title_description_equal.h
+++ b/vendor/blaze/src/alterschema/linter/title_description_equal.h
@@ -15,7 +15,7 @@ class TitleDescriptionEqual final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/title_trailing_period.h b/vendor/blaze/src/alterschema/linter/title_trailing_period.h
index 3ca5d47f..06df64fb 100644
--- a/vendor/blaze/src/alterschema/linter/title_trailing_period.h
+++ b/vendor/blaze/src/alterschema/linter/title_trailing_period.h
@@ -15,7 +15,7 @@ class TitleTrailingPeriod final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/title_trim.h b/vendor/blaze/src/alterschema/linter/title_trim.h
index f594335c..8b779aaa 100644
--- a/vendor/blaze/src/alterschema/linter/title_trim.h
+++ b/vendor/blaze/src/alterschema/linter/title_trim.h
@@ -14,7 +14,7 @@ class TitleTrim final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/top_level_description.h b/vendor/blaze/src/alterschema/linter/top_level_description.h
index c5f37c47..7480e0c5 100644
--- a/vendor/blaze/src/alterschema/linter/top_level_description.h
+++ b/vendor/blaze/src/alterschema/linter/top_level_description.h
@@ -15,9 +15,9 @@ class TopLevelDescription final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
-    ONLY_CONTINUE_IF(location.pointer.empty());
+    ONLY_CONTINUE_IF(!location.parent.has_value());
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
          SchemaVocabularies::Known::JSON_SCHEMA_2019_09_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/top_level_examples.h b/vendor/blaze/src/alterschema/linter/top_level_examples.h
index 6a6c8dbb..a4d21a8a 100644
--- a/vendor/blaze/src/alterschema/linter/top_level_examples.h
+++ b/vendor/blaze/src/alterschema/linter/top_level_examples.h
@@ -15,9 +15,9 @@ class TopLevelExamples final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
-    ONLY_CONTINUE_IF(location.pointer.empty());
+    ONLY_CONTINUE_IF(!location.parent.has_value());
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
          SchemaVocabularies::Known::JSON_SCHEMA_2019_09_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/top_level_title.h b/vendor/blaze/src/alterschema/linter/top_level_title.h
index 50dc22d7..face2a28 100644
--- a/vendor/blaze/src/alterschema/linter/top_level_title.h
+++ b/vendor/blaze/src/alterschema/linter/top_level_title.h
@@ -15,9 +15,9 @@ class TopLevelTitle final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
-    ONLY_CONTINUE_IF(location.pointer.empty());
+    ONLY_CONTINUE_IF(!location.parent.has_value());
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_META_DATA,
          SchemaVocabularies::Known::JSON_SCHEMA_2019_09_META_DATA,
diff --git a/vendor/blaze/src/alterschema/linter/unevaluated_items_default.h b/vendor/blaze/src/alterschema/linter/unevaluated_items_default.h
index 44cfdf8d..0544be0d 100644
--- a/vendor/blaze/src/alterschema/linter/unevaluated_items_default.h
+++ b/vendor/blaze/src/alterschema/linter/unevaluated_items_default.h
@@ -19,7 +19,7 @@ class UnevaluatedItemsDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/unevaluated_properties_default.h b/vendor/blaze/src/alterschema/linter/unevaluated_properties_default.h
index 79aabe83..1588283e 100644
--- a/vendor/blaze/src/alterschema/linter/unevaluated_properties_default.h
+++ b/vendor/blaze/src/alterschema/linter/unevaluated_properties_default.h
@@ -19,7 +19,7 @@ class UnevaluatedPropertiesDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/unknown_format_prefix.h b/vendor/blaze/src/alterschema/linter/unknown_format_prefix.h
index e1d0111c..356c2e9f 100644
--- a/vendor/blaze/src/alterschema/linter/unknown_format_prefix.h
+++ b/vendor/blaze/src/alterschema/linter/unknown_format_prefix.h
@@ -17,7 +17,7 @@ class UnknownFormatPrefix final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(schema.is_object() && schema.defines("format"));
     const auto &format_value{schema.at("format")};
diff --git a/vendor/blaze/src/alterschema/linter/unnecessary_allof_ref_wrapper_modern.h b/vendor/blaze/src/alterschema/linter/unnecessary_allof_ref_wrapper_modern.h
index 69038e36..eb9d8a7e 100644
--- a/vendor/blaze/src/alterschema/linter/unnecessary_allof_ref_wrapper_modern.h
+++ b/vendor/blaze/src/alterschema/linter/unnecessary_allof_ref_wrapper_modern.h
@@ -14,7 +14,7 @@ class UnnecessaryAllOfRefWrapperModern final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_APPLICATOR,
diff --git a/vendor/blaze/src/alterschema/linter/unnecessary_allof_wrapper.h b/vendor/blaze/src/alterschema/linter/unnecessary_allof_wrapper.h
index 815a4561..3e49d26d 100644
--- a/vendor/blaze/src/alterschema/linter/unnecessary_allof_wrapper.h
+++ b/vendor/blaze/src/alterschema/linter/unnecessary_allof_wrapper.h
@@ -15,7 +15,7 @@ class UnnecessaryAllOfWrapper final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &frame,
             const SchemaFrame::Location &location, const SchemaWalker &walker,
-            const SchemaResolver &, const bool) const
+            const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_APPLICATOR,
diff --git a/vendor/blaze/src/alterschema/linter/unnecessary_extends_wrapper.h b/vendor/blaze/src/alterschema/linter/unnecessary_extends_wrapper.h
index a4cae6ba..72eb1385 100644
--- a/vendor/blaze/src/alterschema/linter/unnecessary_extends_wrapper.h
+++ b/vendor/blaze/src/alterschema/linter/unnecessary_extends_wrapper.h
@@ -15,7 +15,7 @@ class UnnecessaryExtendsWrapper final : public SchemaTransformRule {
   condition(const JSON &schema, const JSON &,
             const SchemaVocabularies &vocabularies, const SchemaFrame &frame,
             const SchemaFrame::Location &location, const SchemaWalker &walker,
-            const SchemaResolver &, const bool) const
+            const SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(vocabularies.contains_any(
         {SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_3,
diff --git a/vendor/blaze/src/alterschema/linter/unsatisfiable_max_contains.h b/vendor/blaze/src/alterschema/linter/unsatisfiable_max_contains.h
index da553a64..ad665f63 100644
--- a/vendor/blaze/src/alterschema/linter/unsatisfiable_max_contains.h
+++ b/vendor/blaze/src/alterschema/linter/unsatisfiable_max_contains.h
@@ -16,7 +16,7 @@ class UnsatisfiableMaxContains final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/unsatisfiable_min_properties.h b/vendor/blaze/src/alterschema/linter/unsatisfiable_min_properties.h
index 99cc2c4a..3f07a1ee 100644
--- a/vendor/blaze/src/alterschema/linter/unsatisfiable_min_properties.h
+++ b/vendor/blaze/src/alterschema/linter/unsatisfiable_min_properties.h
@@ -15,7 +15,7 @@ class UnsatisfiableMinProperties final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &,
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
-            const sourcemeta::core::SchemaResolver &, const bool) const
+            const sourcemeta::core::SchemaResolver &) const
       -> SchemaTransformRule::Result override {
     ONLY_CONTINUE_IF(
         vocabularies.contains_any(
diff --git a/vendor/blaze/src/alterschema/linter/valid_default.h b/vendor/blaze/src/alterschema/linter/valid_default.h
index 4d7feee7..792b3f33 100644
--- a/vendor/blaze/src/alterschema/linter/valid_default.h
+++ b/vendor/blaze/src/alterschema/linter/valid_default.h
@@ -14,7 +14,7 @@ class ValidDefault final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &resolver, const bool) const
+            const sourcemeta::core::SchemaResolver &resolver) const
       -> SchemaTransformRule::Result override {
     using Known = SchemaVocabularies::Known;
     // Technically, the `default` keyword goes back to Draft 1, but Blaze
@@ -72,34 +72,14 @@ class ValidDefault final : public SchemaTransformRule {
       return {{{"default"}}, std::move(message).str()};
     }
 
-    // Deliberately framed without a default identifier, so that the root
-    // comes back empty exactly when the schema declares none of its own
-    sourcemeta::core::SchemaFrame declared_frame{
-        sourcemeta::core::SchemaFrame::Mode::Root, root, walker, resolver,
-        location.dialect};
-    std::string_view default_id{location.base};
-    if (!declared_frame.root().empty() || default_id.empty()) {
-      default_id = "";
-    }
-
     sourcemeta::core::WeakPointer base;
-    const auto subschema{
-        sourcemeta::blaze::wrap(root, frame, location, walker, resolver, base)};
-    Template schema_template;
-    try {
-      schema_template = compile(subschema, walker, resolver, this->compiler_,
-                                Mode::Exhaustive, location.dialect, default_id);
-    } catch (const CompilerReferenceTargetNotSchemaError &) {
-      throw;
-    } catch (const sourcemeta::core::SchemaVocabularyError &) {
-      throw;
-    } catch (...) {
-      return false;
-    }
+    const auto schema_template{compile_non_standalone_subschema(
+        root, frame, location, walker, resolver, this->compiler_, base)};
+    ONLY_CONTINUE_IF(schema_template.has_value());
     SimpleOutput output{instance, base};
     Evaluator evaluator;
-    const auto result{
-        evaluator.validate(schema_template, instance, std::ref(output))};
+    const auto result{evaluator.validate(schema_template.value(), instance,
+                                         std::ref(output))};
     if (result) {
       return false;
     }
diff --git a/vendor/blaze/src/alterschema/linter/valid_examples.h b/vendor/blaze/src/alterschema/linter/valid_examples.h
index c2c129fa..f977e2c0 100644
--- a/vendor/blaze/src/alterschema/linter/valid_examples.h
+++ b/vendor/blaze/src/alterschema/linter/valid_examples.h
@@ -15,7 +15,7 @@ class ValidExamples final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame &frame,
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
-            const sourcemeta::core::SchemaResolver &resolver, const bool) const
+            const sourcemeta::core::SchemaResolver &resolver) const
       -> SchemaTransformRule::Result override {
     using Known = SchemaVocabularies::Known;
     ONLY_CONTINUE_IF(
@@ -81,36 +81,16 @@ class ValidExamples final : public SchemaTransformRule {
       return false;
     }
 
-    // Deliberately framed without a default identifier, so that the root
-    // comes back empty exactly when the schema declares none of its own
-    sourcemeta::core::SchemaFrame declared_frame{
-        sourcemeta::core::SchemaFrame::Mode::Root, root, walker, resolver,
-        location.dialect};
-    std::string_view default_id{location.base};
-    if (!declared_frame.root().empty() || default_id.empty()) {
-      default_id = "";
-    }
-
     sourcemeta::core::WeakPointer base;
-    const auto subschema{
-        sourcemeta::blaze::wrap(root, frame, location, walker, resolver, base)};
-    Template schema_template;
-    try {
-      schema_template = compile(subschema, walker, resolver, this->compiler_,
-                                Mode::Exhaustive, location.dialect, default_id);
-    } catch (const CompilerReferenceTargetNotSchemaError &) {
-      throw;
-    } catch (const sourcemeta::core::SchemaVocabularyError &) {
-      throw;
-    } catch (...) {
-      return false;
-    }
+    const auto schema_template{compile_non_standalone_subschema(
+        root, frame, location, walker, resolver, this->compiler_, base)};
+    ONLY_CONTINUE_IF(schema_template.has_value());
 
     for (const auto &example : schema.at("examples").as_array()) {
       SimpleOutput output{example, base};
       Evaluator evaluator;
-      const auto result{
-          evaluator.validate(schema_template, example, std::ref(output))};
+      const auto result{evaluator.validate(schema_template.value(), example,
+                                           std::ref(output))};
       if (!result) {
         std::ostringstream message;
         message << "Invalid example instance at index " << cursor << "\n";
diff --git a/vendor/blaze/src/alterschema/schema_helpers.h b/vendor/blaze/src/alterschema/schema_helpers.h
index b5865d57..736fd875 100644
--- a/vendor/blaze/src/alterschema/schema_helpers.h
+++ b/vendor/blaze/src/alterschema/schema_helpers.h
@@ -52,20 +52,12 @@ inline auto parse_schema_type(const sourcemeta::core::JSON &type)
   return result;
 }
 
-// The dialect a schema declares, honouring the marker that the upgrade rules
-// leave behind while they walk a document across drafts
 inline auto declared_dialect(const sourcemeta::core::JSON &schema)
     -> std::string_view {
   if (!schema.is_object()) {
     return {};
   }
 
-  const auto *override_value{
-      schema.try_at("x-sourcemeta-dialect-override-subschema")};
-  if (override_value != nullptr && override_value->is_string()) {
-    return override_value->to_string();
-  }
-
   const auto *dialect{schema.try_at("$schema")};
   if (dialect != nullptr && dialect->is_string()) {
     return dialect->to_string();
diff --git a/vendor/blaze/src/alterschema/schema_rule.cc b/vendor/blaze/src/alterschema/schema_rule.cc
index 21435f69..8f6ec26f 100644
--- a/vendor/blaze/src/alterschema/schema_rule.cc
+++ b/vendor/blaze/src/alterschema/schema_rule.cc
@@ -80,9 +80,9 @@ auto SchemaRule::condition(
     const sourcemeta::core::SchemaFrame &,
     const sourcemeta::core::SchemaFrame::Location &location,
     const sourcemeta::core::SchemaWalker &,
-    const sourcemeta::core::SchemaResolver &, const bool) const
+    const sourcemeta::core::SchemaResolver &) const
     -> SchemaTransformRule::Result {
-  if (this->scope_ == Scope::TopLevel && !location.pointer.empty()) {
+  if (this->scope_ == Scope::TopLevel && location.parent.has_value()) {
     return false;
   }
 
diff --git a/vendor/blaze/src/alterschema/transformer.cc b/vendor/blaze/src/alterschema/transformer.cc
index 00989cbe..71fc2db0 100644
--- a/vendor/blaze/src/alterschema/transformer.cc
+++ b/vendor/blaze/src/alterschema/transformer.cc
@@ -38,6 +38,14 @@ auto calculate_health_percentage(const std::size_t subschemas,
   return static_cast<std::uint8_t>(result);
 }
 
+auto reframe(const sourcemeta::blaze::SchemaTransformer::Framer &framer,
+             const sourcemeta::core::JSON &document)
+    -> const sourcemeta::core::SchemaFrame * {
+  const auto &frame{framer(document)};
+  assert(frame.mode() == sourcemeta::core::SchemaFrame::Mode::References);
+  return &frame;
+}
+
 auto check_rules(
     const sourcemeta::core::JSON &schema,
     const sourcemeta::core::SchemaFrame &frame,
@@ -48,8 +56,7 @@ auto check_rules(
     const sourcemeta::core::SchemaResolver &resolver,
     const sourcemeta::blaze::SchemaTransformer::Callback &callback,
     const sourcemeta::core::JSON::String &exclude_keyword,
-    const bool non_mutating_only, const bool is_metaschema)
-    -> std::pair<bool, std::uint8_t> {
+    const bool non_mutating_only) -> std::pair<bool, std::uint8_t> {
   std::unordered_set<sourcemeta::core::Pointer,
                      sourcemeta::core::Pointer::Hasher>
       visited;
@@ -81,7 +88,7 @@ auto check_rules(
 
           const auto outcome{rule->check(current, schema, current_vocabularies,
                                          walker, resolver, frame, location,
-                                         exclude_keyword, is_metaschema)};
+                                         exclude_keyword)};
           if (outcome.applies) {
             subschema_failed = true;
             callback(entry_pointer, rule->name(), rule->message(), outcome,
@@ -134,15 +141,17 @@ auto SchemaTransformRule::rereference(const std::string_view reference,
                                    "The reference broke after transformation");
 }
 
-auto SchemaTransformRule::check(
-    const core::JSON &schema, const core::JSON &root,
-    const core::SchemaVocabularies &vocabularies,
-    const core::SchemaWalker &walker, const core::SchemaResolver &resolver,
-    const core::SchemaFrame &frame, const core::SchemaFrame::Location &location,
-    const core::JSON::String &exclude_keyword, const bool is_metaschema) const
+auto SchemaTransformRule::check(const core::JSON &schema,
+                                const core::JSON &root,
+                                const core::SchemaVocabularies &vocabularies,
+                                const core::SchemaWalker &walker,
+                                const core::SchemaResolver &resolver,
+                                const core::SchemaFrame &frame,
+                                const core::SchemaFrame::Location &location,
+                                const core::JSON::String &exclude_keyword) const
     -> SchemaTransformRule::Result {
   auto result{this->condition(schema, root, vocabularies, frame, location,
-                              walker, resolver, is_metaschema)};
+                              walker, resolver)};
 
   if (result.applies && !exclude_keyword.empty() && schema.is_object()) {
     const auto *exclude_value{schema.try_at(exclude_keyword)};
@@ -164,10 +173,9 @@ auto SchemaTransformer::check(const core::JSON &schema,
                               const SchemaTransformer::Callback &callback,
                               std::string_view default_dialect,
                               std::string_view default_id,
-                              const core::JSON::String &exclude_keyword,
-                              const bool is_metaschema) const
+                              const core::JSON::String &exclude_keyword) const
     -> std::pair<bool, std::uint8_t> {
-  core::SchemaFrame frame{
+  const core::SchemaFrame frame{
       core::SchemaFrame::Mode::References,
       schema,
       walker,
@@ -175,8 +183,20 @@ auto SchemaTransformer::check(const core::JSON &schema,
       default_dialect,
       default_id,
       sourcemeta::core::SchemaFrame::IdentifierMode::Fallback};
-  return check_rules(schema, frame, this->rules_, walker, resolver, callback,
-                     exclude_keyword, false, is_metaschema);
+  return this->check(schema, frame, walker, resolver, callback,
+                     exclude_keyword);
+}
+
+auto SchemaTransformer::check(const core::JSON &document,
+                              const core::SchemaFrame &frame,
+                              const core::SchemaWalker &walker,
+                              const core::SchemaResolver &resolver,
+                              const SchemaTransformer::Callback &callback,
+                              const core::JSON::String &exclude_keyword) const
+    -> std::pair<bool, std::uint8_t> {
+  assert(frame.mode() == core::SchemaFrame::Mode::References);
+  return check_rules(document, frame, this->rules_, walker, resolver, callback,
+                     exclude_keyword, false);
 }
 
 auto SchemaTransformer::apply(core::JSON &schema,
@@ -185,15 +205,33 @@ auto SchemaTransformer::apply(core::JSON &schema,
                               const SchemaTransformer::Callback &callback,
                               std::string_view default_dialect,
                               std::string_view default_id,
-                              const core::JSON::String &exclude_keyword,
-                              const bool is_metaschema) const
+                              const core::JSON::String &exclude_keyword) const
+    -> std::pair<bool, std::uint8_t> {
+  std::optional<core::SchemaFrame> frame;
+  return this->apply(
+      schema,
+      [&frame, &walker, &resolver, default_dialect,
+       default_id](const core::JSON &document) -> const core::SchemaFrame & {
+        frame.emplace(core::SchemaFrame::Mode::References, document, walker,
+                      resolver, default_dialect, default_id,
+                      sourcemeta::core::SchemaFrame::IdentifierMode::Fallback);
+        return frame.value();
+      },
+      walker, resolver, callback, exclude_keyword);
+}
+
+auto SchemaTransformer::apply(core::JSON &document, const Framer &framer,
+                              const core::SchemaWalker &walker,
+                              const core::SchemaResolver &resolver,
+                              const SchemaTransformer::Callback &callback,
+                              const core::JSON::String &exclude_keyword) const
     -> std::pair<bool, std::uint8_t> {
   assert(!this->rules_.empty());
   std::unordered_set<std::tuple<core::Pointer, std::string_view, core::JSON>,
                      ProcessedRuleHasher>
       processed_rules;
 
-  std::optional<core::SchemaFrame> frame;
+  const core::SchemaFrame *frame{nullptr};
 
   struct PotentiallyBrokenReference {
     core::Pointer origin;
@@ -207,14 +245,12 @@ auto SchemaTransformer::apply(core::JSON &schema,
   std::vector<PotentiallyBrokenReference> potentially_broken_references;
 
   while (true) {
-    if (!frame.has_value()) {
-      if (schema.is_boolean()) {
+    if (frame == nullptr) {
+      if (document.is_boolean()) {
         break;
       }
 
-      frame.emplace(core::SchemaFrame::Mode::References, schema, walker,
-                    resolver, default_dialect, default_id,
-                    sourcemeta::core::SchemaFrame::IdentifierMode::Fallback);
+      frame = reframe(framer, document);
     }
 
     std::unordered_set<core::Pointer, core::Pointer::Hasher> visited;
@@ -230,7 +266,7 @@ auto SchemaTransformer::apply(core::JSON &schema,
             return false;
           }
           const auto &entry_pointer{*visited_iterator};
-          auto &current{core::get(schema, entry_pointer)};
+          auto &current{core::get(document, entry_pointer)};
           const auto current_vocabularies{
               frame->vocabularies(location, resolver)};
 
@@ -240,9 +276,9 @@ auto SchemaTransformer::apply(core::JSON &schema,
               continue;
             }
 
-            auto outcome{rule->check(current, schema, current_vocabularies,
+            auto outcome{rule->check(current, document, current_vocabularies,
                                      walker, resolver, *frame, location,
-                                     exclude_keyword, is_metaschema)};
+                                     exclude_keyword)};
 
             if (!outcome.applies) {
               continue;
@@ -276,10 +312,7 @@ auto SchemaTransformer::apply(core::JSON &schema,
             applied = true;
 
             if (reframe_after_transform) {
-              frame.emplace(
-                  core::SchemaFrame::Mode::References, schema, walker, resolver,
-                  default_dialect, default_id,
-                  sourcemeta::core::SchemaFrame::IdentifierMode::Fallback);
+              frame = reframe(framer, document);
             } else if (current.is_boolean()) {
               std::tuple<core::Pointer, std::string_view, core::JSON> mark{
                   entry_pointer, rule->name(), current};
@@ -289,7 +322,7 @@ auto SchemaTransformer::apply(core::JSON &schema,
               }
 
               processed_rules.emplace(std::move(mark));
-              frame.reset();
+              frame = nullptr;
               return true;
             }
 
@@ -304,13 +337,13 @@ auto SchemaTransformer::apply(core::JSON &schema,
                 new_location.value().get().relative_pointer};
             const auto current_slice{entry_pointer.slice(resource_offset)};
             for (const auto &saved_reference : potentially_broken_references) {
-              if (core::try_get(schema, saved_reference.target_pointer)) {
+              if (core::try_get(document, saved_reference.target_pointer)) {
                 continue;
               }
 
               // If the origin was also relocated, resolve its new location
               auto effective_origin{saved_reference.origin};
-              if (!core::try_get(schema, saved_reference.origin.initial())) {
+              if (!core::try_get(document, saved_reference.origin.initial())) {
                 try {
                   const auto new_origin{rule->rereference(
                       saved_reference.destination, saved_reference.origin,
@@ -322,7 +355,7 @@ auto SchemaTransformer::apply(core::JSON &schema,
                 } catch (...) {
                   continue;
                 }
-                if (!core::try_get(schema, effective_origin.initial())) {
+                if (!core::try_get(document, effective_origin.initial())) {
                   continue;
                 }
               }
@@ -342,7 +375,7 @@ auto SchemaTransformer::apply(core::JSON &schema,
 
               core::URI original{saved_reference.original};
               original.fragment(core::to_string(new_fragment));
-              core::set(schema, effective_origin,
+              core::set(document, effective_origin,
                         core::JSON{original.recompose()});
               references_fixed = true;
             }
@@ -350,9 +383,9 @@ auto SchemaTransformer::apply(core::JSON &schema,
             const auto new_vocabularies{
                 frame->vocabularies(new_location.value().get(), resolver)};
 
-            if (rule->check(current, schema, new_vocabularies, walker, resolver,
-                            *frame, new_location.value().get(), exclude_keyword,
-                            is_metaschema)
+            if (rule->check(current, document, new_vocabularies, walker,
+                            resolver, *frame, new_location.value().get(),
+                            exclude_keyword)
                     .applies) {
               std::ostringstream error;
               error << "Rule condition holds after application: "
@@ -370,7 +403,7 @@ auto SchemaTransformer::apply(core::JSON &schema,
             processed_rules.emplace(std::move(mark));
 
             if (references_fixed) {
-              frame.reset();
+              frame = nullptr;
             }
 
             if (references_fixed || reframe_after_transform) {
@@ -386,18 +419,16 @@ auto SchemaTransformer::apply(core::JSON &schema,
     }
   }
 
-  if (!frame.has_value() && !schema.is_boolean()) {
-    frame.emplace(core::SchemaFrame::Mode::References, schema, walker, resolver,
-                  default_dialect, default_id,
-                  sourcemeta::core::SchemaFrame::IdentifierMode::Fallback);
+  if (frame == nullptr && !document.is_boolean()) {
+    frame = reframe(framer, document);
   }
 
-  if (!frame.has_value()) {
+  if (frame == nullptr) {
     return {true, static_cast<std::uint8_t>(100)};
   }
 
-  return check_rules(schema, *frame, this->rules_, walker, resolver, callback,
-                     exclude_keyword, true, is_metaschema);
+  return check_rules(document, *frame, this->rules_, walker, resolver, callback,
+                     exclude_keyword, true);
 }
 
 auto SchemaTransformer::remove(const std::string_view name) -> bool {
diff --git a/vendor/blaze/src/bundle/bundle.cc b/vendor/blaze/src/bundle/bundle.cc
index e326f9c7..7512fd62 100644
--- a/vendor/blaze/src/bundle/bundle.cc
+++ b/vendor/blaze/src/bundle/bundle.cc
@@ -364,6 +364,7 @@ auto bundle_schema(sourcemeta::core::JSON &root,
                    std::string_view default_dialect,
                    std::string_view default_id,
                    const sourcemeta::core::SchemaFrame::Paths &paths,
+                   std::string_view default_base,
                    std::unordered_map<sourcemeta::core::JSON::String,
                                       sourcemeta::core::JSON::String> &bundled,
                    std::uint64_t &remaining, const std::size_t depth = 0)
@@ -376,8 +377,11 @@ auto bundle_schema(sourcemeta::core::JSON &root,
       sourcemeta::core::SchemaFrame::Mode::References, subschema, walker,
       resolver, default_dialect, default_id,
       sourcemeta::core::SchemaFrame::IdentifierMode::Additional,
-      // We only want to frame in "wrapper" mode for the top level object
-      depth == 0 ? paths : NESTED_PATHS, "", remaining};
+      // We only want to frame in "wrapper" mode for the top level object, which
+      // is also the only one that the base the caller retrieved it from applies
+      // to, as every remote carries the identity it was resolved by
+      depth == 0 ? paths : NESTED_PATHS,
+      depth == 0 ? default_base : std::string_view{}, remaining};
   charge(remaining, frame);
 
   std::vector<std::tuple<sourcemeta::core::JSON, sourcemeta::core::JSON::String,
@@ -549,8 +553,8 @@ auto bundle_schema(sourcemeta::core::JSON &root,
 
   for (auto &[remote, effective_id, remote_dialect] : deferred) {
     bundle_schema(root, container, remote, walker, resolver, mode,
-                  default_dialect, effective_id, paths, bundled, remaining,
-                  depth + 1);
+                  default_dialect, effective_id, paths, default_base, bundled,
+                  remaining, depth + 1);
     elevate_embedded_resources(remote, root, container, remote_dialect, walker,
                                resolver, default_dialect, bundled, remaining);
     embed_schema(root, container, effective_id, std::move(remote));
@@ -589,8 +593,8 @@ static auto bundle_internal(
     const sourcemeta::core::SchemaResolver &resolver, const BundleMode mode,
     std::string_view default_dialect, std::string_view default_id,
     const std::optional<sourcemeta::core::Pointer> &default_container,
-    const sourcemeta::core::SchemaFrame::Paths &paths, std::uint64_t &remaining)
-    -> void {
+    const sourcemeta::core::SchemaFrame::Paths &paths,
+    std::string_view default_base, std::uint64_t &remaining) -> void {
   // Pre-scan the schema to find any already-embedded schemas and mark them
   // as bundled to avoid re-embedding them. This includes the root schema itself
   // and any schemas already embedded within it
@@ -606,7 +610,7 @@ static auto bundle_internal(
       default_id,
       sourcemeta::core::SchemaFrame::IdentifierMode::Additional,
       paths,
-      "",
+      default_base,
       remaining};
   charge(remaining, initial_frame);
   initial_frame.for_each_resource_uri([&bundled](const auto &uri) -> void {
@@ -617,7 +621,8 @@ static auto bundle_internal(
     // This is undefined behavior
     assert(!default_container.value().empty());
     bundle_schema(schema, default_container.value(), schema, walker, resolver,
-                  mode, default_dialect, default_id, paths, bundled, remaining);
+                  mode, default_dialect, default_id, paths, default_base,
+                  bundled, remaining);
     return;
   }
 
@@ -675,7 +680,7 @@ static auto bundle_internal(
         default_id,
         sourcemeta::core::SchemaFrame::IdentifierMode::Additional,
         {sourcemeta::core::EMPTY_WEAK_POINTER},
-        "",
+        default_base,
         remaining};
     charge(remaining, frame);
     if (frame.standalone()) {
@@ -708,7 +713,7 @@ static auto bundle_internal(
 
   bundle_schema(schema, {sourcemeta::core::JSON::String{container_keyword}},
                 schema, walker, resolver, mode, default_dialect, default_id,
-                paths, bundled, remaining);
+                paths, default_base, bundled, remaining);
 }
 
 auto bundle(sourcemeta::core::JSON &schema,
@@ -718,11 +723,12 @@ auto bundle(sourcemeta::core::JSON &schema,
             std::string_view default_id,
             const std::optional<sourcemeta::core::Pointer> &default_container,
             const sourcemeta::core::SchemaFrame::Paths &paths,
-            const std::uint64_t max_locations) -> void {
+            std::string_view default_base, const std::uint64_t max_locations)
+    -> void {
   auto remaining{max_locations};
   try {
     bundle_internal(schema, walker, resolver, mode, default_dialect, default_id,
-                    default_container, paths, remaining);
+                    default_container, paths, default_base, remaining);
   } catch (const sourcemeta::core::SchemaFrameLimitError &) {
     // Every frame spends from what is left rather than from the whole, so the
     // one that ran out reports what it was handed. The caller set the limit
@@ -738,10 +744,11 @@ auto bundle(const sourcemeta::core::JSON &schema,
             std::string_view default_id,
             const std::optional<sourcemeta::core::Pointer> &default_container,
             const sourcemeta::core::SchemaFrame::Paths &paths,
-            const std::uint64_t max_locations) -> sourcemeta::core::JSON {
+            std::string_view default_base, const std::uint64_t max_locations)
+    -> sourcemeta::core::JSON {
   sourcemeta::core::JSON copy = schema;
   bundle(copy, walker, resolver, mode, default_dialect, default_id,
-         default_container, paths, max_locations);
+         default_container, paths, default_base, max_locations);
   return copy;
 }
 
diff --git a/vendor/blaze/src/bundle/helpers.h b/vendor/blaze/src/bundle/helpers.h
index 73454a0a..9eccfa75 100644
--- a/vendor/blaze/src/bundle/helpers.h
+++ b/vendor/blaze/src/bundle/helpers.h
@@ -87,10 +87,7 @@ inline auto ref_overrides_adjacent_keywords(
   }
 }
 
-// The dialect a schema declares, falling back to the given default. Unlike
-// the equivalent helper in alterschema, this one knows nothing about the
-// dialect override marker, as only the upgrade rules ever write one and
-// bundling can never observe a document while those are live
+// The dialect a schema declares, falling back to the given default
 inline auto declared_dialect(const sourcemeta::core::JSON &schema,
                              const std::string_view default_dialect)
     -> std::string_view {
diff --git a/vendor/blaze/src/bundle/include/sourcemeta/blaze/bundle.h b/vendor/blaze/src/bundle/include/sourcemeta/blaze/bundle.h
index 3baf7a96..d67de7b2 100644
--- a/vendor/blaze/src/bundle/include/sourcemeta/blaze/bundle.h
+++ b/vendor/blaze/src/bundle/include/sourcemeta/blaze/bundle.h
@@ -160,6 +160,12 @@ auto dependencies(
 /// assert(document == expected);
 /// ```
 ///
+/// Pass `default_base` to state the base URI that the document was retrieved
+/// from, which a relative reference within any of the given `paths` resolves
+/// against. As with sourcemeta::core::SchemaFrame, this does not claim that the
+/// document declares an identifier, so bundling never writes it into the
+/// document
+///
 /// How many schemas this ends up embedding follows from what the resolver
 /// hands back rather than from the schema the caller passed in, so pass
 /// `max_locations` to bound it. Every frame that bundling constructs spends
@@ -178,6 +184,7 @@ auto bundle(
         std::nullopt,
     const sourcemeta::core::SchemaFrame::Paths &paths =
         {sourcemeta::core::EMPTY_WEAK_POINTER},
+    std::string_view default_base = "",
     std::uint64_t max_locations = std::numeric_limits<std::uint64_t>::max())
     -> void;
 
@@ -248,6 +255,7 @@ auto bundle(
         std::nullopt,
     const sourcemeta::core::SchemaFrame::Paths &paths =
         {sourcemeta::core::EMPTY_WEAK_POINTER},
+    std::string_view default_base = "",
     std::uint64_t max_locations = std::numeric_limits<std::uint64_t>::max())
     -> sourcemeta::core::JSON;
 
diff --git a/vendor/blaze/src/canonicalizer/canonicalize.cc b/vendor/blaze/src/canonicalizer/canonicalize.cc
index e6191fbf..e5acf67c 100644
--- a/vendor/blaze/src/canonicalizer/canonicalize.cc
+++ b/vendor/blaze/src/canonicalizer/canonicalize.cc
@@ -7,7 +7,8 @@
 
 #include "schema_helpers.h"
 
-#include <algorithm>     // std::sort, std::unique, std::ranges::none_of
+#include <algorithm>     // std::sort, std::unique, std::ranges::contains,
+                         // std::ranges::none_of
 #include <array>         // std::array
 #include <bit>           // std::popcount
 #include <cassert>       // assert
diff --git a/vendor/blaze/src/canonicalizer/rules/type_union_distribute_keywords.h b/vendor/blaze/src/canonicalizer/rules/type_union_distribute_keywords.h
index 7bcaba58..a752b979 100644
--- a/vendor/blaze/src/canonicalizer/rules/type_union_distribute_keywords.h
+++ b/vendor/blaze/src/canonicalizer/rules/type_union_distribute_keywords.h
@@ -8,8 +8,8 @@ class TypeUnionDistributeKeywords final : public SchemaTransformRule {
   condition(const sourcemeta::core::JSON &schema,
             const sourcemeta::core::JSON &,
             const sourcemeta::core::SchemaVocabularies &vocabularies,
-            const sourcemeta::core::SchemaFrame &,
-            const sourcemeta::core::SchemaFrame::Location &,
+            const sourcemeta::core::SchemaFrame &frame,
+            const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
             const sourcemeta::core::SchemaResolver &) const -> bool override {
     ONLY_CONTINUE_IF(
@@ -28,6 +28,10 @@ class TypeUnionDistributeKeywords final : public SchemaTransformRule {
     this->wrap_keywords_.clear();
     this->wrap_ = false;
     std::vector<sourcemeta::core::JSON::String> movable;
+    // Walking the frame is linear on the entire document, so only do it if a
+    // keyword really is about to be copied into more than one branch, and
+    // remember the outcome for the keywords that follow
+    std::optional<std::vector<std::string_view>> declaring;
     for (const auto &entry : schema.as_object()) {
       // `required` is a property-presence flag, not a value assertion, so it
       // is never pushed into a branch
@@ -66,10 +70,32 @@ class TypeUnionDistributeKeywords final : public SchemaTransformRule {
           break;
         }
 
+        // `additionalProperties` and `additionalItems` only apply to what
+        // their siblings do not already cover, so moving one of them next to
+        // different siblings, or a sibling next to one of them, would change
+        // what it covers
+        if (changes_leftovers(entry.first, entry.second, type->at(index))) {
+          conflict = true;
+          break;
+        }
+
         targets.push_back(index);
       }
 
-      if (!has_match || conflict) {
+      // Copying a value that declares an identifier or an anchor into more
+      // than one branch would declare it more than once. Wrap instead so each
+      // declaration is only ever moved
+      bool duplicates_identifier{false};
+      if (!this->wrap_ && targets.size() > 1) {
+        if (!declaring.has_value()) {
+          declaring = declaring_keywords(frame, location.pointer);
+        }
+
+        duplicates_identifier =
+            std::ranges::contains(declaring.value(), entry.first);
+      }
+
+      if (!has_match || conflict || duplicates_identifier) {
         this->wrap_ = true;
       } else {
         this->moves_.emplace_back(entry.first, std::move(targets));
@@ -171,6 +197,81 @@ class TypeUnionDistributeKeywords final : public SchemaTransformRule {
   }
 
 private:
+  // Whether the given keyword takes properties away from
+  // `additionalProperties`. An empty one takes nothing away
+  static auto narrows(const sourcemeta::core::JSON &schema,
+                      const sourcemeta::core::JSON::String &keyword) -> bool {
+    const auto *value{schema.try_at(keyword)};
+    return (value != nullptr) && value->is_object() && !value->empty();
+  }
+
+  // Whether the given keyword of the given schema still constrains anything
+  static auto constrains(const sourcemeta::core::JSON &schema,
+                         const sourcemeta::core::JSON::String &keyword)
+      -> bool {
+    const auto *value{schema.try_at(keyword)};
+    return (value != nullptr) && !is_empty_schema(*value);
+  }
+
+  // `additionalProperties` and `additionalItems` constrain whatever their
+  // siblings leave over, so what they cover depends on the company they keep.
+  // Vacuous siblings leave everything over, and a vacuous leftovers keyword
+  // accepts whatever reaches it, so neither of those changes anything
+  static auto changes_leftovers(const sourcemeta::core::JSON::String &keyword,
+                                const sourcemeta::core::JSON &value,
+                                const sourcemeta::core::JSON &branch) -> bool {
+    if (keyword == "additionalProperties") {
+      return !is_empty_schema(value) && (narrows(branch, "properties") ||
+                                         narrows(branch, "patternProperties"));
+    }
+
+    if (keyword == "properties" || keyword == "patternProperties") {
+      return value.is_object() && !value.empty() &&
+             constrains(branch, "additionalProperties");
+    }
+
+    // A dormant `additionalItems` normally gets dropped when its schema has
+    // no tuple `items`, but not while a reference points through it. Moving
+    // such a one next to a tuple `items` would wake it up
+    if (keyword == "additionalItems") {
+      const auto *items{branch.try_at("items")};
+      return !is_empty_schema(value) && (items != nullptr) && items->is_array();
+    }
+
+    if (keyword == "items") {
+      return value.is_array() && constrains(branch, "additionalItems");
+    }
+
+    return false;
+  }
+
+  // The keywords of the given schema whose value declares an identifier or an
+  // anchor anywhere inside it
+  static auto declaring_keywords(const sourcemeta::core::SchemaFrame &frame,
+                                 const sourcemeta::core::WeakPointer &base)
+      -> std::vector<std::string_view> {
+    std::vector<std::string_view> result;
+    frame.for_each_location(
+        [&base, &result](
+            const sourcemeta::core::SchemaReferenceType, const std::string_view,
+            const sourcemeta::core::SchemaFrame::Location &candidate) -> void {
+          if ((candidate.type ==
+                   sourcemeta::core::SchemaFrame::LocationType::Resource ||
+               candidate.type ==
+                   sourcemeta::core::SchemaFrame::LocationType::Anchor) &&
+              candidate.pointer.size() > base.size() &&
+              candidate.pointer.starts_with(base) &&
+              candidate.pointer.at(base.size()).is_property()) {
+            const std::string_view keyword{
+                candidate.pointer.at(base.size()).to_property()};
+            if (!std::ranges::contains(result, keyword)) {
+              result.push_back(keyword);
+            }
+          }
+        });
+    return result;
+  }
+
   static auto branch_type_set(const sourcemeta::core::JSON &branch)
       -> sourcemeta::core::JSON::TypeSet {
     if (!branch.is_object()) {
diff --git a/vendor/blaze/src/canonicalizer/schema_helpers.h b/vendor/blaze/src/canonicalizer/schema_helpers.h
index 04e03ed6..e9412516 100644
--- a/vendor/blaze/src/canonicalizer/schema_helpers.h
+++ b/vendor/blaze/src/canonicalizer/schema_helpers.h
@@ -53,20 +53,12 @@ inline auto parse_schema_type(const sourcemeta::core::JSON &type)
   return result;
 }
 
-// The dialect a schema declares, honouring the marker that the upgrade rules
-// leave behind while they walk a document across drafts
 inline auto declared_dialect(const sourcemeta::core::JSON &schema)
     -> std::string_view {
   if (!schema.is_object()) {
     return {};
   }
 
-  const auto *override_value{
-      schema.try_at("x-sourcemeta-dialect-override-subschema")};
-  if (override_value != nullptr && override_value->is_string()) {
-    return override_value->to_string();
-  }
-
   const auto *dialect{schema.try_at("$schema")};
   if (dialect != nullptr && dialect->is_string()) {
     return dialect->to_string();
diff --git a/vendor/blaze/src/compiler/compile.cc b/vendor/blaze/src/compiler/compile.cc
index d33296b4..286078ca 100644
--- a/vendor/blaze/src/compiler/compile.cc
+++ b/vendor/blaze/src/compiler/compile.cc
@@ -492,9 +492,14 @@ auto entrypoint_names_non_schema(const sourcemeta::core::JSON &schema,
       sourcemeta::core::JSON::String{})};
   const auto base_location{frame.traverse(base)};
   if (!base_location.has_value()) {
-    // A base that framing does not know names some other document, which this
-    // one has nothing to say about
-    return base.empty() &&
+    // A base that framing does not locate is either the one the caller framed
+    // a wrapper document with, which addresses that document from its top, or
+    // one that names some other document, which this one has nothing to say
+    // about
+    return (base.empty() ||
+            frame.any_subschema(
+                [&base](const sourcemeta::core::SchemaFrame::Location &location)
+                    -> bool { return location.base == base; })) &&
            sourcemeta::core::try_get(schema, relative.value()) != nullptr;
   }
 
@@ -565,6 +570,17 @@ auto compile(const sourcemeta::core::JSON &schema,
         resources.emplace_back(uri);
       });
 
+  // A schema that declares no identifier is still addressed by the base the
+  // caller framed it with, which is what its instructions report as their
+  // resource
+  frame.for_each_subschema(
+      [&resources](
+          const sourcemeta::core::SchemaFrame::Location &location) -> void {
+        if (!location.base.empty()) {
+          resources.emplace_back(location.base);
+        }
+      });
+
   // Rule out any duplicates as we will use this list as the
   // source for a perfect hash function on schema resources.
   std::ranges::sort(resources);
@@ -820,7 +836,7 @@ auto compile(const sourcemeta::core::JSON &schema,
   const sourcemeta::core::JSON result{sourcemeta::blaze::bundle(
       schema, walker, resolver, sourcemeta::blaze::BundleMode::References,
       default_dialect, default_id, std::nullopt,
-      {sourcemeta::core::EMPTY_WEAK_POINTER}, max_locations)};
+      {sourcemeta::core::EMPTY_WEAK_POINTER}, "", max_locations)};
 
   sourcemeta::core::SchemaFrame frame{
       sourcemeta::core::SchemaFrame::Mode::References,
diff --git a/vendor/blaze/src/compiler/compile_helpers.h b/vendor/blaze/src/compiler/compile_helpers.h
index f6daf4f9..dcc61505 100644
--- a/vendor/blaze/src/compiler/compile_helpers.h
+++ b/vendor/blaze/src/compiler/compile_helpers.h
@@ -328,6 +328,17 @@ unsigned_integer_property(const sourcemeta::core::JSON &document,
   return unsigned_integer_property(document, property).value_or(otherwise);
 }
 
+// Whether the frame addresses the document from its top under the given base,
+// which is what the base that the caller framed a wrapper document with does
+inline auto addresses_document_top(const sourcemeta::core::SchemaFrame &frame,
+                                   const sourcemeta::core::JSON::String &base)
+    -> bool {
+  return frame.any_subschema(
+      [&base](const sourcemeta::core::SchemaFrame::Location &location) -> bool {
+        return location.base == base && location.relative_pointer == 0;
+      });
+}
+
 // A schema context only knows where it sits within the schema resource that
 // encloses it, while an error must report where the problem is within the
 // document that the schema came from. Prepending the pointer of that resource
@@ -338,13 +349,15 @@ absolute_schema_location(const Context &context,
                          const sourcemeta::core::URI &base,
                          const sourcemeta::core::WeakPointer &relative_pointer)
     -> sourcemeta::core::Pointer {
+  const auto base_string{base.recompose()};
   const auto resource{context.frame.location(
-      sourcemeta::core::SchemaReferenceType::Static, base.recompose())};
-  // Framing is where this base came from, so the resource it names is there.
-  // Were that to stop holding, the relative pointer is all we could report,
-  // and it would silently mean something else, so catch the drift here
-  assert(resource.has_value());
-  if (!resource.has_value()) [[unlikely]] {
+      sourcemeta::core::SchemaReferenceType::Static, base_string)};
+  // A base with no location of its own is the one the caller framed a wrapper
+  // document with, under which every relative pointer starts at the top of
+  // that document. Missing the resource of any other base would silently
+  // report a pointer that means something else, so catch that drift here
+  if (!resource.has_value()) {
+    assert(addresses_document_top(context.frame, base_string));
     return to_pointer(relative_pointer);
   }
 
@@ -365,10 +378,11 @@ absolute_schema_pointer(const Context &context,
                         const sourcemeta::core::URI &base,
                         const sourcemeta::core::WeakPointer &relative_pointer)
     -> sourcemeta::core::WeakPointer {
+  const auto base_string{base.recompose()};
   const auto resource{context.frame.location(
-      sourcemeta::core::SchemaReferenceType::Static, base.recompose())};
-  assert(resource.has_value());
-  if (!resource.has_value()) [[unlikely]] {
+      sourcemeta::core::SchemaReferenceType::Static, base_string)};
+  if (!resource.has_value()) {
+    assert(addresses_document_top(context.frame, base_string));
     return relative_pointer;
   }
 
diff --git a/vendor/blaze/src/convert/CMakeLists.txt b/vendor/blaze/src/convert/CMakeLists.txt
new file mode 100644
index 00000000..eace7226
--- /dev/null
+++ b/vendor/blaze/src/convert/CMakeLists.txt
@@ -0,0 +1,33 @@
+sourcemeta_library(NAMESPACE sourcemeta PROJECT blaze NAME convert
+  FOLDER "Blaze/Convert"
+  PRIVATE_HEADERS error.h
+  SOURCES convert.cc
+    rule.h
+    helpers.h
+
+    # Rules
+    rules/definitions_to_defs.h
+    rules/draft_official_dialect_with_https.h
+    rules/draft_official_dialect_without_empty_fragment.h
+    rules/empty_object_as_true.h
+    rules/enum_to_const.h
+    rules/prefix_promoted_2020_12_keywords.h
+    rules/prefix_promoted_draft_2019_09_keywords.h
+    rules/prefix_promoted_draft_4_keywords.h
+    rules/prefix_promoted_draft_6_keywords.h
+    rules/prefix_promoted_draft_7_keywords.h
+    rules/upgrade_2019_09_to_2020_12.h
+    rules/upgrade_dialect_override_cleanup.h
+    rules/upgrade_draft_3_to_draft_4.h
+    rules/upgrade_draft_4_to_draft_6.h
+    rules/upgrade_draft_6_to_draft_7.h
+    rules/upgrade_draft_7_to_draft_2019_09.h)
+
+if(BLAZE_INSTALL)
+  sourcemeta_library_install(NAMESPACE sourcemeta PROJECT blaze NAME convert)
+endif()
+
+target_link_libraries(sourcemeta_blaze_convert PUBLIC
+  sourcemeta::core::jsonschema)
+target_link_libraries(sourcemeta_blaze_convert PRIVATE
+  sourcemeta::core::uri)
diff --git a/vendor/blaze/src/convert/convert.cc b/vendor/blaze/src/convert/convert.cc
new file mode 100644
index 00000000..2426994a
--- /dev/null
+++ b/vendor/blaze/src/convert/convert.cc
@@ -0,0 +1,312 @@
+#include <sourcemeta/blaze/convert.h>
+#include <sourcemeta/core/jsonschema.h>
+
+#include <sourcemeta/core/json.h>
+#include <sourcemeta/core/jsonpointer.h>
+#include <sourcemeta/core/uri.h>
+
+#include <algorithm> // std::ranges::any_of
+#include <array>     // std::array
+#include <cassert>   // assert
+#include <concepts>  // std::derived_from
+#include <cstddef>   // std::size_t
+#include <cstdint>   // std::uint64_t
+#include <functional> // std::cref, std::function, std::hash, std::reference_wrapper
+#include <map>        // std::map
+#include <memory>     // std::make_unique, std::unique_ptr
+#include <optional>      // std::optional, std::nullopt
+#include <set>           // std::set
+#include <string>        // std::string
+#include <string_view>   // std::string_view
+#include <tuple>         // std::tuple
+#include <type_traits>   // std::is_same_v, std::true_type, std::false_type
+#include <unordered_map> // std::unordered_map
+#include <unordered_set> // std::unordered_set
+#include <utility>       // std::move, std::pair
+#include <vector>        // std::vector
+
+namespace sourcemeta::blaze {
+
+using namespace sourcemeta::core;
+
+namespace {
+
+#include "rule.h"
+
+using Rule = std::tuple<std::unique_ptr<SchemaTransformRule>, bool>;
+
+/// Construct a rule entry for the given rule type
+template <std::derived_from<SchemaTransformRule> T>
+[[nodiscard]] auto make_rule() -> Rule {
+  return {std::make_unique<T>(),
+          std::is_same_v<typename T::reframe_after_transform, std::true_type>};
+}
+
+/// Apply the given rules top-down to every subschema until none of them applies
+auto apply(const std::vector<Rule> &rules, sourcemeta::core::JSON &schema,
+           const sourcemeta::core::SchemaWalker &walker,
+           const sourcemeta::core::SchemaResolver &resolver,
+           const std::string_view default_dialect,
+           const std::string_view default_id, const bool is_metaschema)
+    -> void {
+  assert(!rules.empty());
+
+  struct ProcessedRuleHasher {
+    auto operator()(const std::tuple<core::Pointer, std::string_view,
+                                     core::JSON> &value) const noexcept
+        -> std::size_t {
+      return core::Pointer::Hasher{}(std::get<0>(value)) ^
+             (std::hash<std::string_view>{}(std::get<1>(value)) << 1) ^
+             (std::hash<std::uint64_t>{}(std::get<2>(value).fast_hash()) << 2);
+    }
+  };
+
+  std::unordered_set<std::tuple<core::Pointer, std::string_view, core::JSON>,
+                     ProcessedRuleHasher>
+      processed_rules;
+
+  std::optional<core::SchemaFrame> frame;
+
+  struct PotentiallyBrokenReference {
+    core::Pointer origin;
+    core::JSON::String original;
+    core::JSON::String destination;
+    core::JSON::String fragment;
+    core::Pointer target_pointer;
+    std::size_t target_relative_pointer;
+  };
+
+  std::vector<PotentiallyBrokenReference> potentially_broken_references;
+
+  while (true) {
+    if (!frame.has_value()) {
+      if (schema.is_boolean()) {
+        break;
+      }
+
+      frame.emplace(core::SchemaFrame::Mode::References, schema, walker,
+                    resolver, default_dialect, default_id,
+                    sourcemeta::core::SchemaFrame::IdentifierMode::Fallback);
+    }
+
+    std::unordered_set<core::Pointer, core::Pointer::Hasher> visited;
+    bool applied{false};
+
+    // Stopping the traversal stands in for the restart that the
+    // rules request once they mutate the schema
+    [[maybe_unused]] const auto restarted{frame->any_subschema(
+        [&](const core::SchemaFrame::Location &location) -> bool {
+          const auto [visited_iterator, inserted] =
+              visited.insert(core::to_pointer(location.pointer));
+          if (!inserted) {
+            return false;
+          }
+          const auto &entry_pointer{*visited_iterator};
+          auto &current{core::get(schema, entry_pointer)};
+          const auto current_vocabularies{
+              frame->vocabularies(location, resolver)};
+
+          for (const auto &[rule, reframe_after_transform] : rules) {
+            const auto outcome{
+                rule->condition(current, schema, current_vocabularies, *frame,
+                                location, walker, resolver, is_metaschema)};
+
+            if (!outcome) {
+              continue;
+            }
+
+            potentially_broken_references.clear();
+            frame->for_each_reference([&](const core::SchemaReferenceType,
+                                          const core::WeakPointer &origin,
+                                          const core::SchemaFrame::Reference
+                                              &reference) -> void {
+              const auto destination{frame->traverse(reference.destination)};
+              if (!destination.has_value() || !reference.fragment.has_value() ||
+                  !reference.fragment.value().starts_with('/')) {
+                return;
+              }
+
+              const auto &target{destination.value().get()};
+              potentially_broken_references.push_back(
+                  {.origin = core::to_pointer(origin),
+                   .original = core::JSON::String{reference.original},
+                   .destination = reference.destination,
+                   .fragment = core::JSON::String{reference.fragment.value()},
+                   .target_pointer = core::to_pointer(target.pointer),
+                   .target_relative_pointer = target.relative_pointer});
+            });
+
+            rule->transform(current);
+
+            applied = true;
+
+            if (reframe_after_transform) {
+              frame.emplace(
+                  core::SchemaFrame::Mode::References, schema, walker, resolver,
+                  default_dialect, default_id,
+                  sourcemeta::core::SchemaFrame::IdentifierMode::Fallback);
+            } else if (current.is_boolean()) {
+              std::tuple<core::Pointer, std::string_view, core::JSON> mark{
+                  entry_pointer, rule->name(), current};
+              assert(!processed_rules.contains(mark));
+              processed_rules.emplace(std::move(mark));
+              frame.reset();
+              return true;
+            }
+
+            const auto new_location{
+                frame->traverse(core::to_weak_pointer(entry_pointer))};
+            assert(new_location.has_value());
+
+            // Fix broken references before re-checking the condition,
+            // as the re-check may mutate rule state that rereference needs
+            bool references_fixed{false};
+            const auto resource_offset{
+                new_location.value().get().relative_pointer};
+            const auto current_slice{entry_pointer.slice(resource_offset)};
+            for (const auto &saved_reference : potentially_broken_references) {
+              if (core::try_get(schema, saved_reference.target_pointer)) {
+                continue;
+              }
+
+              // If the origin was also relocated, resolve its new location
+              auto effective_origin{saved_reference.origin};
+              if (!core::try_get(schema, saved_reference.origin.initial())) {
+                const auto new_origin{rule->rereference(
+                    saved_reference.destination, saved_reference.origin,
+                    saved_reference.origin.slice(resource_offset),
+                    current_slice)};
+                if (!new_origin.has_value()) {
+                  continue;
+                }
+                effective_origin =
+                    saved_reference.origin.slice(0, resource_offset)
+                        .concat(new_origin.value());
+                if (!core::try_get(schema, effective_origin.initial())) {
+                  continue;
+                }
+              }
+
+              const auto new_relative{rule->rereference(
+                  saved_reference.destination, saved_reference.origin,
+                  saved_reference.target_pointer.slice(
+                      saved_reference.target_relative_pointer),
+                  current_slice)};
+              if (!new_relative.has_value()) {
+                throw ConvertBrokenReferenceError{saved_reference.destination,
+                                                  saved_reference.origin};
+              }
+              const auto new_fragment{
+                  saved_reference.fragment ==
+                          core::to_string(saved_reference.target_pointer)
+                      ? saved_reference.target_pointer
+                            .slice(0, saved_reference.target_relative_pointer)
+                            .concat(new_relative.value())
+                      : new_relative.value()};
+
+              core::URI original{saved_reference.original};
+              original.fragment(core::to_string(new_fragment));
+              core::set(schema, effective_origin,
+                        core::JSON{original.recompose()});
+              references_fixed = true;
+            }
+
+            const auto new_vocabularies{
+                frame->vocabularies(new_location.value().get(), resolver)};
+
+            assert(!rule->condition(current, schema, new_vocabularies, *frame,
+                                    new_location.value().get(), walker,
+                                    resolver, is_metaschema));
+
+            std::tuple<core::Pointer, std::string_view, core::JSON> mark{
+                entry_pointer, rule->name(), current};
+            assert(!processed_rules.contains(mark));
+            processed_rules.emplace(std::move(mark));
+
+            if (references_fixed) {
+              frame.reset();
+            }
+
+            if (references_fixed || reframe_after_transform) {
+              return true;
+            }
+          }
+
+          return false;
+        })};
+
+    if (!applied) {
+      break;
+    }
+  }
+}
+
+#include "helpers.h"
+
+#include "rules/definitions_to_defs.h"
+#include "rules/draft_official_dialect_with_https.h"
+#include "rules/draft_official_dialect_without_empty_fragment.h"
+#include "rules/empty_object_as_true.h"
+#include "rules/enum_to_const.h"
+#include "rules/prefix_promoted_2020_12_keywords.h"
+#include "rules/prefix_promoted_draft_2019_09_keywords.h"
+#include "rules/prefix_promoted_draft_4_keywords.h"
+#include "rules/prefix_promoted_draft_6_keywords.h"
+#include "rules/prefix_promoted_draft_7_keywords.h"
+#include "rules/upgrade_2019_09_to_2020_12.h"
+#include "rules/upgrade_dialect_override_cleanup.h"
+#include "rules/upgrade_draft_3_to_draft_4.h"
+#include "rules/upgrade_draft_4_to_draft_6.h"
+#include "rules/upgrade_draft_6_to_draft_7.h"
+#include "rules/upgrade_draft_7_to_draft_2019_09.h"
+
+#undef ONLY_CONTINUE_IF
+
+} // namespace
+
+auto convert(sourcemeta::core::JSON &schema,
+             const sourcemeta::core::SchemaWalker &walker,
+             const sourcemeta::core::SchemaResolver &resolver,
+             const ConvertTarget target, const std::string_view default_dialect,
+             const std::string_view default_id, const bool is_metaschema)
+    -> void {
+  std::vector<Rule> rules;
+  rules.reserve(17);
+  rules.push_back(make_rule<DraftOfficialDialectWithHttps>());
+  rules.push_back(make_rule<DraftOfficialDialectWithoutEmptyFragment>());
+  rules.push_back(make_rule<PrefixPromotedDraft4Keywords>());
+  rules.push_back(make_rule<UpgradeDraft3ToDraft4>());
+
+  if (target == ConvertTarget::Draft6 || target == ConvertTarget::Draft7 ||
+      target == ConvertTarget::Draft201909 ||
+      target == ConvertTarget::Draft202012) {
+    rules.push_back(make_rule<PrefixPromotedDraft6Keywords>());
+    rules.push_back(make_rule<UpgradeDraft4ToDraft6>());
+    rules.push_back(make_rule<EmptyObjectAsTrue>());
+  }
+
+  if (target == ConvertTarget::Draft7 || target == ConvertTarget::Draft201909 ||
+      target == ConvertTarget::Draft202012) {
+    rules.push_back(make_rule<PrefixPromotedDraft7Keywords>());
+    rules.push_back(make_rule<UpgradeDraft6ToDraft7>());
+    rules.push_back(make_rule<EnumToConst>());
+  }
+
+  if (target == ConvertTarget::Draft201909 ||
+      target == ConvertTarget::Draft202012) {
+    rules.push_back(make_rule<PrefixPromoted201909Keywords>());
+    rules.push_back(make_rule<UpgradeDraft7To201909>());
+    rules.push_back(make_rule<DefinitionsToDefs>());
+  }
+
+  if (target == ConvertTarget::Draft202012) {
+    rules.push_back(make_rule<PrefixPromoted202012Keywords>());
+    rules.push_back(make_rule<Upgrade201909To202012>());
+  }
+
+  rules.push_back(make_rule<UpgradeDialectOverrideCleanup>());
+  apply(rules, schema, walker, resolver, default_dialect, default_id,
+        is_metaschema);
+}
+
+} // namespace sourcemeta::blaze
diff --git a/vendor/blaze/src/alterschema/upgrade/helpers.h b/vendor/blaze/src/convert/helpers.h
similarity index 61%
rename from vendor/blaze/src/alterschema/upgrade/helpers.h
rename to vendor/blaze/src/convert/helpers.h
index d496d4c0..00449369 100644
--- a/vendor/blaze/src/alterschema/upgrade/helpers.h
+++ b/vendor/blaze/src/convert/helpers.h
@@ -1,18 +1,42 @@
+#ifndef SOURCEMETA_BLAZE_CONVERT_HELPERS_H_
+#define SOURCEMETA_BLAZE_CONVERT_HELPERS_H_
+
 // NOLINTNEXTLINE(cert-err58-cpp,bugprone-throwing-static-initialization)
-static const std::string DIALECT_OVERRIDE_KEYWORD{
+const std::string DIALECT_OVERRIDE_KEYWORD{
     "x-sourcemeta-dialect-override-subschema"};
 
-static auto mark_dialect_override(sourcemeta::core::JSON &schema,
+// The dialect a schema declares, honouring the marker that the upgrade rules
+// leave behind while they walk a document across drafts
+inline auto declared_dialect(const sourcemeta::core::JSON &schema)
+    -> std::string_view {
+  if (!schema.is_object()) {
+    return {};
+  }
+
+  const auto *override_value{schema.try_at(DIALECT_OVERRIDE_KEYWORD)};
+  if (override_value != nullptr && override_value->is_string()) {
+    return override_value->to_string();
+  }
+
+  const auto *dialect{schema.try_at("$schema")};
+  if (dialect != nullptr && dialect->is_string()) {
+    return dialect->to_string();
+  }
+
+  return {};
+}
+
+inline auto mark_dialect_override(sourcemeta::core::JSON &schema,
                                   const std::string_view dialect) -> void {
   schema.assign(DIALECT_OVERRIDE_KEYWORD, sourcemeta::core::JSON{dialect});
 }
 
-static auto current_dialect_or_override(const sourcemeta::core::JSON &schema)
+inline auto current_dialect_or_override(const sourcemeta::core::JSON &schema)
     -> std::string_view {
   return declared_dialect(schema);
 }
 
-static auto
+inline auto
 subschema_at_dialect(const sourcemeta::core::JSON &schema,
                      const sourcemeta::core::SchemaFrame::Location &location,
                      const std::string_view dialect) -> bool {
@@ -23,7 +47,7 @@ subschema_at_dialect(const sourcemeta::core::JSON &schema,
   return schema.is_object() && location.pointer.empty();
 }
 
-static auto drop_dialect_overrides(sourcemeta::core::JSON &schema,
+inline auto drop_dialect_overrides(sourcemeta::core::JSON &schema,
                                    const bool is_root) -> void {
   if (schema.is_array()) {
     for (auto &item : schema.as_array()) {
@@ -58,7 +82,7 @@ struct AnchorCharPolicy {
   std::function<bool(char)> is_valid_body;
 };
 
-static auto sanitize_anchor_with_policy(const std::string_view original,
+inline auto sanitize_anchor_with_policy(const std::string_view original,
                                         const std::set<std::string> &in_use,
                                         const AnchorCharPolicy &policy)
     -> std::string {
@@ -73,3 +97,10 @@ static auto sanitize_anchor_with_policy(const std::string_view original,
   }
   return sanitized;
 }
+
+#define ONLY_CONTINUE_IF(condition)                                            \
+  if (!(condition)) {                                                          \
+    return false;                                                              \
+  }
+
+#endif
diff --git a/vendor/blaze/src/convert/include/sourcemeta/blaze/convert.h b/vendor/blaze/src/convert/include/sourcemeta/blaze/convert.h
new file mode 100644
index 00000000..66252b0f
--- /dev/null
+++ b/vendor/blaze/src/convert/include/sourcemeta/blaze/convert.h
@@ -0,0 +1,75 @@
+#ifndef SOURCEMETA_BLAZE_CONVERT_H_
+#define SOURCEMETA_BLAZE_CONVERT_H_
+
+/// @defgroup convert Convert
+/// @brief Convert a JSON Schema from one dialect to another.
+///
+/// This functionality is included as follows:
+///
+/// ```cpp
+/// #include <sourcemeta/blaze/convert.h>
+/// ```
+
+#ifndef SOURCEMETA_BLAZE_CONVERT_EXPORT
+#include <sourcemeta/blaze/convert_export.h>
+#endif
+
+#include <sourcemeta/blaze/convert_error.h>
+
+#include <sourcemeta/core/json.h>
+#include <sourcemeta/core/jsonschema.h>
+
+#include <cstdint>     // std::uint8_t
+#include <string_view> // std::string_view
+
+namespace sourcemeta::blaze {
+
+/// @ingroup convert
+/// The dialect to convert a schema to
+enum class ConvertTarget : std::uint8_t {
+  /// JSON Schema Draft 4
+  Draft4,
+
+  /// JSON Schema Draft 6
+  Draft6,
+
+  /// JSON Schema Draft 7
+  Draft7,
+
+  /// JSON Schema 2019-09
+  Draft201909,
+
+  /// JSON Schema 2020-12
+  Draft202012,
+};
+
+/// @ingroup convert
+/// Convert the given schema, in place, to the given dialect. Only upgrades are
+/// supported, so a schema already on that dialect or a newer one is left as
+/// is. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/blaze/convert.h>
+/// #include <sourcemeta/core/jsonschema.h>
+///
+/// auto schema = sourcemeta::core::parse_json(R"JSON({
+///   "$schema": "http://json-schema.org/draft-04/schema#",
+///   "type": "string"
+/// })JSON");
+///
+/// sourcemeta::blaze::convert(schema, sourcemeta::core::schema_walker,
+///                            sourcemeta::core::schema_resolver,
+///                            sourcemeta::blaze::ConvertTarget::Draft202012);
+/// ```
+SOURCEMETA_BLAZE_CONVERT_EXPORT
+auto convert(sourcemeta::core::JSON &schema,
+             const sourcemeta::core::SchemaWalker &walker,
+             const sourcemeta::core::SchemaResolver &resolver,
+             const ConvertTarget target,
+             const std::string_view default_dialect = "",
+             const std::string_view default_id = "",
+             const bool is_metaschema = false) -> void;
+
+} // namespace sourcemeta::blaze
+
+#endif
diff --git a/vendor/blaze/src/convert/include/sourcemeta/blaze/convert_error.h b/vendor/blaze/src/convert/include/sourcemeta/blaze/convert_error.h
new file mode 100644
index 00000000..fa790f01
--- /dev/null
+++ b/vendor/blaze/src/convert/include/sourcemeta/blaze/convert_error.h
@@ -0,0 +1,57 @@
+#ifndef SOURCEMETA_BLAZE_CONVERT_ERROR_H_
+#define SOURCEMETA_BLAZE_CONVERT_ERROR_H_
+
+#ifndef SOURCEMETA_BLAZE_CONVERT_EXPORT
+#include <sourcemeta/blaze/convert_export.h>
+#endif
+
+#include <sourcemeta/core/jsonpointer.h>
+
+#include <exception>   // std::exception
+#include <string>      // std::string
+#include <string_view> // std::string_view
+#include <utility>     // std::move
+
+namespace sourcemeta::blaze {
+
+// Exporting symbols that depends on the standard C++ library is considered
+// safe.
+// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
+#if defined(_MSC_VER)
+#pragma warning(disable : 4251 4275)
+#endif
+
+/// @ingroup convert
+/// An error that represents a broken schema reference after conversion
+class SOURCEMETA_BLAZE_CONVERT_EXPORT ConvertBrokenReferenceError
+    : public std::exception {
+public:
+  ConvertBrokenReferenceError(const std::string_view identifier,
+                              sourcemeta::core::Pointer location)
+      : identifier_{identifier}, location_{std::move(location)} {}
+
+  [[nodiscard]] auto what() const noexcept -> const char * override {
+    return "The reference broke after transformation";
+  }
+
+  [[nodiscard]] auto identifier() const noexcept -> std::string_view {
+    return this->identifier_;
+  }
+
+  [[nodiscard]] auto location() const noexcept
+      -> const sourcemeta::core::Pointer & {
+    return this->location_;
+  }
+
+private:
+  std::string identifier_;
+  sourcemeta::core::Pointer location_;
+};
+
+#if defined(_MSC_VER)
+#pragma warning(default : 4251 4275)
+#endif
+
+} // namespace sourcemeta::blaze
+
+#endif
diff --git a/vendor/blaze/src/convert/rule.h b/vendor/blaze/src/convert/rule.h
new file mode 100644
index 00000000..c7b91ff2
--- /dev/null
+++ b/vendor/blaze/src/convert/rule.h
@@ -0,0 +1,45 @@
+#ifndef SOURCEMETA_BLAZE_CONVERT_RULE_H_
+#define SOURCEMETA_BLAZE_CONVERT_RULE_H_
+
+class SchemaTransformRule {
+public:
+  SchemaTransformRule(const std::string_view name) : name_{name} {}
+
+  virtual ~SchemaTransformRule() = default;
+
+  SchemaTransformRule(const SchemaTransformRule &) = delete;
+  SchemaTransformRule(SchemaTransformRule &&) = delete;
+  auto operator=(const SchemaTransformRule &) -> SchemaTransformRule & = delete;
+  auto operator=(SchemaTransformRule &&) -> SchemaTransformRule & = delete;
+
+  [[nodiscard]] auto name() const noexcept -> std::string_view {
+    return this->name_;
+  }
+
+  /// A method to optionally fix any reference location that was affected by the
+  /// transformation
+  [[nodiscard]] virtual auto
+  rereference(const std::string_view, const sourcemeta::core::Pointer &,
+              const sourcemeta::core::Pointer &,
+              const sourcemeta::core::Pointer &) const
+      -> std::optional<sourcemeta::core::Pointer> {
+    return std::nullopt;
+  }
+
+  [[nodiscard]] virtual auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &root,
+            const sourcemeta::core::SchemaVocabularies &vocabularies,
+            const sourcemeta::core::SchemaFrame &frame,
+            const sourcemeta::core::SchemaFrame::Location &location,
+            const sourcemeta::core::SchemaWalker &walker,
+            const sourcemeta::core::SchemaResolver &resolver,
+            const bool is_metaschema) const -> bool = 0;
+
+  virtual auto transform(sourcemeta::core::JSON &schema) const -> void = 0;
+
+private:
+  const std::string name_{};
+};
+
+#endif
diff --git a/vendor/blaze/src/convert/rules/definitions_to_defs.h b/vendor/blaze/src/convert/rules/definitions_to_defs.h
new file mode 100644
index 00000000..42cf0d9c
--- /dev/null
+++ b/vendor/blaze/src/convert/rules/definitions_to_defs.h
@@ -0,0 +1,36 @@
+class DefinitionsToDefs final : public SchemaTransformRule {
+public:
+  using reframe_after_transform = std::true_type;
+  DefinitionsToDefs() : SchemaTransformRule{"definitions_to_defs"} {};
+
+  [[nodiscard]] auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &,
+            const sourcemeta::core::SchemaVocabularies &vocabularies,
+            const sourcemeta::core::SchemaFrame &,
+            const sourcemeta::core::SchemaFrame::Location &,
+            const sourcemeta::core::SchemaWalker &,
+            const sourcemeta::core::SchemaResolver &, const bool) const
+      -> bool override {
+    ONLY_CONTINUE_IF(
+        vocabularies.contains_any(
+            {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_CORE,
+             SchemaVocabularies::Known::JSON_SCHEMA_2019_09_CORE}) &&
+        schema.is_object() && schema.defines("definitions") &&
+        !schema.defines("$defs"));
+    return true;
+  }
+
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    schema.rename("definitions", "$defs");
+  }
+
+  [[nodiscard]] auto rereference(const std::string_view,
+                                 const sourcemeta::core::Pointer &,
+                                 const sourcemeta::core::Pointer &target,
+                                 const sourcemeta::core::Pointer &current) const
+      -> std::optional<sourcemeta::core::Pointer> override {
+    return target.rebase(current.concat("definitions"),
+                         current.concat("$defs"));
+  }
+};
diff --git a/vendor/blaze/src/convert/rules/draft_official_dialect_with_https.h b/vendor/blaze/src/convert/rules/draft_official_dialect_with_https.h
new file mode 100644
index 00000000..a9c8110f
--- /dev/null
+++ b/vendor/blaze/src/convert/rules/draft_official_dialect_with_https.h
@@ -0,0 +1,72 @@
+class DraftOfficialDialectWithHttps final : public SchemaTransformRule {
+public:
+  using reframe_after_transform = std::true_type;
+  DraftOfficialDialectWithHttps()
+      : SchemaTransformRule{"draft_official_dialect_with_https"} {};
+
+  [[nodiscard]] auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &,
+            const sourcemeta::core::SchemaVocabularies &,
+            const sourcemeta::core::SchemaFrame &,
+            const sourcemeta::core::SchemaFrame::Location &location,
+            const sourcemeta::core::SchemaWalker &,
+            const sourcemeta::core::SchemaResolver &, const bool) const
+      -> bool override {
+    using sourcemeta::core::SchemaBaseDialect;
+    ONLY_CONTINUE_IF(
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_7 ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_7_HYPER ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_6 ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_6_HYPER ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_4 ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_4_HYPER ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_3 ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_3_HYPER ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_2_HYPER ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_1_HYPER ||
+        location.base_dialect == SchemaBaseDialect::JSON_SCHEMA_DRAFT_0_HYPER);
+    ONLY_CONTINUE_IF(schema.is_object());
+    const auto *schema_keyword{schema.try_at("$schema")};
+    ONLY_CONTINUE_IF(schema_keyword && schema_keyword->is_string());
+    const auto &dialect{schema_keyword->to_string()};
+    ONLY_CONTINUE_IF(dialect.starts_with("https://json-schema.org/"));
+    ONLY_CONTINUE_IF(
+        dialect == "https://json-schema.org/draft-07/schema" ||
+        dialect == "https://json-schema.org/draft-07/schema#" ||
+        dialect == "https://json-schema.org/draft-07/hyper-schema" ||
+        dialect == "https://json-schema.org/draft-07/hyper-schema#" ||
+        dialect == "https://json-schema.org/draft-06/schema" ||
+        dialect == "https://json-schema.org/draft-06/schema#" ||
+        dialect == "https://json-schema.org/draft-06/hyper-schema" ||
+        dialect == "https://json-schema.org/draft-06/hyper-schema#" ||
+        dialect == "https://json-schema.org/draft-04/schema" ||
+        dialect == "https://json-schema.org/draft-04/schema#" ||
+        dialect == "https://json-schema.org/draft-04/hyper-schema" ||
+        dialect == "https://json-schema.org/draft-04/hyper-schema#" ||
+        dialect == "https://json-schema.org/draft-03/schema" ||
+        dialect == "https://json-schema.org/draft-03/schema#" ||
+        dialect == "https://json-schema.org/draft-03/hyper-schema" ||
+        dialect == "https://json-schema.org/draft-03/hyper-schema#" ||
+        dialect == "https://json-schema.org/draft-02/schema" ||
+        dialect == "https://json-schema.org/draft-02/schema#" ||
+        dialect == "https://json-schema.org/draft-02/hyper-schema" ||
+        dialect == "https://json-schema.org/draft-02/hyper-schema#" ||
+        dialect == "https://json-schema.org/draft-01/schema" ||
+        dialect == "https://json-schema.org/draft-01/schema#" ||
+        dialect == "https://json-schema.org/draft-01/hyper-schema" ||
+        dialect == "https://json-schema.org/draft-01/hyper-schema#" ||
+        dialect == "https://json-schema.org/draft-00/schema" ||
+        dialect == "https://json-schema.org/draft-00/schema#" ||
+        dialect == "https://json-schema.org/draft-00/hyper-schema" ||
+        dialect == "https://json-schema.org/draft-00/hyper-schema#");
+    return true;
+  }
+
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    const auto &old_dialect{schema.at("$schema").to_string()};
+    std::string new_dialect{"http://"};
+    new_dialect += old_dialect.substr(8);
+    schema.at("$schema").into(sourcemeta::core::JSON{new_dialect});
+  }
+};
diff --git a/vendor/blaze/src/convert/rules/draft_official_dialect_without_empty_fragment.h b/vendor/blaze/src/convert/rules/draft_official_dialect_without_empty_fragment.h
new file mode 100644
index 00000000..2f36787c
--- /dev/null
+++ b/vendor/blaze/src/convert/rules/draft_official_dialect_without_empty_fragment.h
@@ -0,0 +1,43 @@
+class DraftOfficialDialectWithoutEmptyFragment final
+    : public SchemaTransformRule {
+public:
+  using reframe_after_transform = std::true_type;
+  DraftOfficialDialectWithoutEmptyFragment()
+      : SchemaTransformRule{"draft_official_dialect_without_empty_fragment"} {};
+
+  [[nodiscard]] auto condition(const sourcemeta::core::JSON &schema,
+                               const sourcemeta::core::JSON &,
+                               const sourcemeta::core::SchemaVocabularies &,
+                               const sourcemeta::core::SchemaFrame &,
+                               const sourcemeta::core::SchemaFrame::Location &,
+                               const sourcemeta::core::SchemaWalker &,
+                               const sourcemeta::core::SchemaResolver &,
+                               const bool) const -> bool override {
+    ONLY_CONTINUE_IF(schema.is_object());
+    const auto *schema_keyword{schema.try_at("$schema")};
+    ONLY_CONTINUE_IF(schema_keyword && schema_keyword->is_string());
+    const auto &dialect{schema_keyword->to_string()};
+    ONLY_CONTINUE_IF(
+        dialect == "http://json-schema.org/draft-07/schema" ||
+        dialect == "http://json-schema.org/draft-07/hyper-schema" ||
+        dialect == "http://json-schema.org/draft-06/schema" ||
+        dialect == "http://json-schema.org/draft-06/hyper-schema" ||
+        dialect == "http://json-schema.org/draft-04/schema" ||
+        dialect == "http://json-schema.org/draft-04/hyper-schema" ||
+        dialect == "http://json-schema.org/draft-03/schema" ||
+        dialect == "http://json-schema.org/draft-03/hyper-schema" ||
+        dialect == "http://json-schema.org/draft-02/schema" ||
+        dialect == "http://json-schema.org/draft-02/hyper-schema" ||
+        dialect == "http://json-schema.org/draft-01/schema" ||
+        dialect == "http://json-schema.org/draft-01/hyper-schema" ||
+        dialect == "http://json-schema.org/draft-00/schema" ||
+        dialect == "http://json-schema.org/draft-00/hyper-schema");
+    return true;
+  }
+
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto dialect{std::move(schema.at("$schema")).to_string()};
+    dialect += "#";
+    schema.at("$schema").into(sourcemeta::core::JSON{dialect});
+  }
+};
diff --git a/vendor/blaze/src/convert/rules/empty_object_as_true.h b/vendor/blaze/src/convert/rules/empty_object_as_true.h
new file mode 100644
index 00000000..eca2d0ae
--- /dev/null
+++ b/vendor/blaze/src/convert/rules/empty_object_as_true.h
@@ -0,0 +1,28 @@
+class EmptyObjectAsTrue final : public SchemaTransformRule {
+public:
+  using reframe_after_transform = std::false_type;
+  EmptyObjectAsTrue() : SchemaTransformRule{"empty_object_as_true"} {};
+
+  [[nodiscard]] auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &,
+            const sourcemeta::core::SchemaVocabularies &vocabularies,
+            const sourcemeta::core::SchemaFrame &,
+            const sourcemeta::core::SchemaFrame::Location &,
+            const sourcemeta::core::SchemaWalker &,
+            const sourcemeta::core::SchemaResolver &, const bool) const
+      -> bool override {
+    ONLY_CONTINUE_IF(vocabularies.contains_any(
+                         {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_CORE,
+                          SchemaVocabularies::Known::JSON_SCHEMA_2019_09_CORE,
+                          SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_7,
+                          SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_6,
+                          SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_4}) &&
+                     schema.is_object() && schema.empty());
+    return true;
+  }
+
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    schema.into(sourcemeta::core::JSON{true});
+  }
+};
diff --git a/vendor/blaze/src/convert/rules/enum_to_const.h b/vendor/blaze/src/convert/rules/enum_to_const.h
new file mode 100644
index 00000000..f95a68b4
--- /dev/null
+++ b/vendor/blaze/src/convert/rules/enum_to_const.h
@@ -0,0 +1,34 @@
+class EnumToConst final : public SchemaTransformRule {
+public:
+  using reframe_after_transform = std::true_type;
+  EnumToConst() : SchemaTransformRule{"enum_to_const"} {};
+
+  [[nodiscard]] auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &,
+            const sourcemeta::core::SchemaVocabularies &vocabularies,
+            const sourcemeta::core::SchemaFrame &,
+            const sourcemeta::core::SchemaFrame::Location &,
+            const sourcemeta::core::SchemaWalker &,
+            const sourcemeta::core::SchemaResolver &, const bool) const
+      -> bool override {
+    ONLY_CONTINUE_IF(
+        vocabularies.contains_any(
+            {SchemaVocabularies::Known::JSON_SCHEMA_2020_12_VALIDATION,
+             SchemaVocabularies::Known::JSON_SCHEMA_2019_09_VALIDATION,
+             SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_7,
+             SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_6}) &&
+        schema.is_object() && !schema.defines("const"));
+
+    const auto *enum_value{schema.try_at("enum")};
+    ONLY_CONTINUE_IF(enum_value && enum_value->is_array() &&
+                     enum_value->size() == 1);
+    return true;
+  }
+
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    auto front{schema.at("enum").front()};
+    schema.at("enum").into(front);
+    schema.rename("enum", "const");
+  }
+};
diff --git a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_2020_12_keywords.h b/vendor/blaze/src/convert/rules/prefix_promoted_2020_12_keywords.h
similarity index 88%
rename from vendor/blaze/src/alterschema/upgrade/prefix_promoted_2020_12_keywords.h
rename to vendor/blaze/src/convert/rules/prefix_promoted_2020_12_keywords.h
index b3b29f0a..3dc230ec 100644
--- a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_2020_12_keywords.h
+++ b/vendor/blaze/src/convert/rules/prefix_promoted_2020_12_keywords.h
@@ -1,9 +1,8 @@
 class PrefixPromoted202012Keywords final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   PrefixPromoted202012Keywords()
-      : SchemaTransformRule{"prefix_promoted_2020_12_keywords", ""} {};
+      : SchemaTransformRule{"prefix_promoted_2020_12_keywords"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class PrefixPromoted202012Keywords final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(vocabularies.contains(
                          SchemaVocabularies::Known::JSON_SCHEMA_2019_09_CORE) &&
                      schema.is_object());
@@ -21,8 +20,7 @@ class PrefixPromoted202012Keywords final : public SchemaTransformRule {
     return schema.defines_any({"prefixItems", "$dynamicAnchor", "$dynamicRef"});
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     this->renames_.clear();
     for (const auto &keyword : KEYWORDS) {
       const std::string keyword_name{keyword};
@@ -44,7 +42,7 @@ class PrefixPromoted202012Keywords final : public SchemaTransformRule {
                                  const sourcemeta::core::Pointer &,
                                  const sourcemeta::core::Pointer &target,
                                  const sourcemeta::core::Pointer &current) const
-      -> sourcemeta::core::Pointer override {
+      -> std::optional<sourcemeta::core::Pointer> override {
     for (const auto &[old_name, new_name] : this->renames_) {
       const auto result{
           target.rebase(current.concat(sourcemeta::core::Pointer{old_name}),
diff --git a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_2019_09_keywords.h b/vendor/blaze/src/convert/rules/prefix_promoted_draft_2019_09_keywords.h
similarity index 89%
rename from vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_2019_09_keywords.h
rename to vendor/blaze/src/convert/rules/prefix_promoted_draft_2019_09_keywords.h
index bd132cef..78b6dbad 100644
--- a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_2019_09_keywords.h
+++ b/vendor/blaze/src/convert/rules/prefix_promoted_draft_2019_09_keywords.h
@@ -1,9 +1,8 @@
 class PrefixPromoted201909Keywords final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   PrefixPromoted201909Keywords()
-      : SchemaTransformRule{"prefix_promoted_2019_09_keywords", ""} {};
+      : SchemaTransformRule{"prefix_promoted_2019_09_keywords"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class PrefixPromoted201909Keywords final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(
         vocabularies.contains(SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_7) &&
         schema.is_object());
@@ -27,8 +26,7 @@ class PrefixPromoted201909Keywords final : public SchemaTransformRule {
     return false;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     this->renames_.clear();
     for (const auto &keyword : KEYWORDS) {
       const std::string keyword_name{keyword};
@@ -50,7 +48,7 @@ class PrefixPromoted201909Keywords final : public SchemaTransformRule {
                                  const sourcemeta::core::Pointer &,
                                  const sourcemeta::core::Pointer &target,
                                  const sourcemeta::core::Pointer &current) const
-      -> sourcemeta::core::Pointer override {
+      -> std::optional<sourcemeta::core::Pointer> override {
     for (const auto &[old_name, new_name] : this->renames_) {
       const auto result{
           target.rebase(current.concat(sourcemeta::core::Pointer{old_name}),
diff --git a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_4_keywords.h b/vendor/blaze/src/convert/rules/prefix_promoted_draft_4_keywords.h
similarity index 88%
rename from vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_4_keywords.h
rename to vendor/blaze/src/convert/rules/prefix_promoted_draft_4_keywords.h
index a44fe9cf..840ab7ea 100644
--- a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_4_keywords.h
+++ b/vendor/blaze/src/convert/rules/prefix_promoted_draft_4_keywords.h
@@ -1,9 +1,8 @@
 class PrefixPromotedDraft4Keywords final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   PrefixPromotedDraft4Keywords()
-      : SchemaTransformRule{"prefix_promoted_draft_4_keywords", ""} {};
+      : SchemaTransformRule{"prefix_promoted_draft_4_keywords"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class PrefixPromotedDraft4Keywords final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(
         vocabularies.contains(SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_3) &&
         schema.is_object());
@@ -27,8 +26,7 @@ class PrefixPromotedDraft4Keywords final : public SchemaTransformRule {
     return false;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     this->renames_.clear();
     for (const auto &keyword : KEYWORDS) {
       const std::string keyword_name{keyword};
@@ -50,7 +48,7 @@ class PrefixPromotedDraft4Keywords final : public SchemaTransformRule {
                                  const sourcemeta::core::Pointer &,
                                  const sourcemeta::core::Pointer &target,
                                  const sourcemeta::core::Pointer &current) const
-      -> sourcemeta::core::Pointer override {
+      -> std::optional<sourcemeta::core::Pointer> override {
     for (const auto &[old_name, new_name] : this->renames_) {
       const auto result{
           target.rebase(current.concat(sourcemeta::core::Pointer{old_name}),
diff --git a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_6_keywords.h b/vendor/blaze/src/convert/rules/prefix_promoted_draft_6_keywords.h
similarity index 88%
rename from vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_6_keywords.h
rename to vendor/blaze/src/convert/rules/prefix_promoted_draft_6_keywords.h
index 20479ea6..90980397 100644
--- a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_6_keywords.h
+++ b/vendor/blaze/src/convert/rules/prefix_promoted_draft_6_keywords.h
@@ -1,9 +1,8 @@
 class PrefixPromotedDraft6Keywords final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   PrefixPromotedDraft6Keywords()
-      : SchemaTransformRule{"prefix_promoted_draft_6_keywords", ""} {};
+      : SchemaTransformRule{"prefix_promoted_draft_6_keywords"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class PrefixPromotedDraft6Keywords final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(
         vocabularies.contains(SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_4) &&
         schema.is_object());
@@ -27,8 +26,7 @@ class PrefixPromotedDraft6Keywords final : public SchemaTransformRule {
     return false;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     this->renames_.clear();
     for (const auto &keyword : KEYWORDS) {
       const std::string keyword_name{keyword};
@@ -50,7 +48,7 @@ class PrefixPromotedDraft6Keywords final : public SchemaTransformRule {
                                  const sourcemeta::core::Pointer &,
                                  const sourcemeta::core::Pointer &target,
                                  const sourcemeta::core::Pointer &current) const
-      -> sourcemeta::core::Pointer override {
+      -> std::optional<sourcemeta::core::Pointer> override {
     for (const auto &[old_name, new_name] : this->renames_) {
       const auto result{
           target.rebase(current.concat(sourcemeta::core::Pointer{old_name}),
diff --git a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_7_keywords.h b/vendor/blaze/src/convert/rules/prefix_promoted_draft_7_keywords.h
similarity index 88%
rename from vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_7_keywords.h
rename to vendor/blaze/src/convert/rules/prefix_promoted_draft_7_keywords.h
index 160d91f4..ad636b2b 100644
--- a/vendor/blaze/src/alterschema/upgrade/prefix_promoted_draft_7_keywords.h
+++ b/vendor/blaze/src/convert/rules/prefix_promoted_draft_7_keywords.h
@@ -1,9 +1,8 @@
 class PrefixPromotedDraft7Keywords final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   PrefixPromotedDraft7Keywords()
-      : SchemaTransformRule{"prefix_promoted_draft_7_keywords", ""} {};
+      : SchemaTransformRule{"prefix_promoted_draft_7_keywords"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class PrefixPromotedDraft7Keywords final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(
         vocabularies.contains(SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_6) &&
         schema.is_object());
@@ -27,8 +26,7 @@ class PrefixPromotedDraft7Keywords final : public SchemaTransformRule {
     return false;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     this->renames_.clear();
     for (const auto &keyword : KEYWORDS) {
       const std::string keyword_name{keyword};
@@ -50,7 +48,7 @@ class PrefixPromotedDraft7Keywords final : public SchemaTransformRule {
                                  const sourcemeta::core::Pointer &,
                                  const sourcemeta::core::Pointer &target,
                                  const sourcemeta::core::Pointer &current) const
-      -> sourcemeta::core::Pointer override {
+      -> std::optional<sourcemeta::core::Pointer> override {
     for (const auto &[old_name, new_name] : this->renames_) {
       const auto result{
           target.rebase(current.concat(sourcemeta::core::Pointer{old_name}),
diff --git a/vendor/blaze/src/alterschema/upgrade/upgrade_2019_09_to_2020_12.h b/vendor/blaze/src/convert/rules/upgrade_2019_09_to_2020_12.h
similarity index 97%
rename from vendor/blaze/src/alterschema/upgrade/upgrade_2019_09_to_2020_12.h
rename to vendor/blaze/src/convert/rules/upgrade_2019_09_to_2020_12.h
index ef8ecd4b..9a39846b 100644
--- a/vendor/blaze/src/alterschema/upgrade/upgrade_2019_09_to_2020_12.h
+++ b/vendor/blaze/src/convert/rules/upgrade_2019_09_to_2020_12.h
@@ -1,9 +1,8 @@
 class Upgrade201909To202012 final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   Upgrade201909To202012()
-      : SchemaTransformRule{"upgrade_2019_09_to_2020_12", ""} {};
+      : SchemaTransformRule{"upgrade_2019_09_to_2020_12"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,9 @@ class Upgrade201909To202012 final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &walker,
             const sourcemeta::core::SchemaResolver &resolver, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
+    this->sanitize_pending_ = false;
+
     ONLY_CONTINUE_IF(vocabularies.contains(
                          SchemaVocabularies::Known::JSON_SCHEMA_2019_09_CORE) &&
                      schema.is_object());
@@ -35,8 +36,8 @@ class Upgrade201909To202012 final : public SchemaTransformRule {
             compute_document_has_unevaluated_items(root, frame, walker,
                                                    resolver);
         this->is_inside_contains_wrapper_ = false;
-        return Result{std::vector<sourcemeta::core::Pointer>{},
-                      std::string{"sanitize"}};
+        this->sanitize_pending_ = true;
+        return true;
       }
     }
 
@@ -58,11 +59,8 @@ class Upgrade201909To202012 final : public SchemaTransformRule {
     return true;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &result) const
-      -> void override {
-    const bool is_sanitize_phase{result.description.has_value() &&
-                                 result.description.value() == "sanitize"};
-    if (is_sanitize_phase) {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    if (this->sanitize_pending_) {
       apply_anchor_sanitization(schema);
       if (this->descendant_has_pending_pattern_) {
         return;
@@ -171,7 +169,7 @@ class Upgrade201909To202012 final : public SchemaTransformRule {
                                  const sourcemeta::core::Pointer &,
                                  const sourcemeta::core::Pointer &target,
                                  const sourcemeta::core::Pointer &current) const
-      -> sourcemeta::core::Pointer override {
+      -> std::optional<sourcemeta::core::Pointer> override {
     for (const auto &[old_pointer, new_pointer] : this->renames_) {
       const auto result{target.rebase(current.concat(old_pointer),
                                       current.concat(new_pointer))};
@@ -290,6 +288,7 @@ class Upgrade201909To202012 final : public SchemaTransformRule {
   mutable bool is_inside_contains_wrapper_{false};
   mutable bool descendant_has_pending_pattern_{false};
   mutable bool document_has_unevaluated_items_{false};
+  mutable bool sanitize_pending_{false};
   mutable std::vector<AnchorRename> anchor_renames_;
   mutable std::vector<AnchorRefRewrite> anchor_ref_rewrites_;
 
diff --git a/vendor/blaze/src/alterschema/upgrade/upgrade_dialect_override_cleanup.h b/vendor/blaze/src/convert/rules/upgrade_dialect_override_cleanup.h
similarity index 84%
rename from vendor/blaze/src/alterschema/upgrade/upgrade_dialect_override_cleanup.h
rename to vendor/blaze/src/convert/rules/upgrade_dialect_override_cleanup.h
index 1d2103f4..a6d2b0b0 100644
--- a/vendor/blaze/src/alterschema/upgrade/upgrade_dialect_override_cleanup.h
+++ b/vendor/blaze/src/convert/rules/upgrade_dialect_override_cleanup.h
@@ -1,9 +1,8 @@
 class UpgradeDialectOverrideCleanup final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   UpgradeDialectOverrideCleanup()
-      : SchemaTransformRule{"upgrade_dialect_override_cleanup", ""} {};
+      : SchemaTransformRule{"upgrade_dialect_override_cleanup"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class UpgradeDialectOverrideCleanup final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(location.pointer.empty() && schema.is_object());
 
     const auto *override_value{schema.try_at(DIALECT_OVERRIDE_KEYWORD)};
@@ -22,8 +21,7 @@ class UpgradeDialectOverrideCleanup final : public SchemaTransformRule {
     return true;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     if (!schema.defines("$schema")) {
       sourcemeta::core::JSON dialect_value{
           schema.at(DIALECT_OVERRIDE_KEYWORD).to_string()};
diff --git a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_3_to_draft_4.h b/vendor/blaze/src/convert/rules/upgrade_draft_3_to_draft_4.h
similarity index 98%
rename from vendor/blaze/src/alterschema/upgrade/upgrade_draft_3_to_draft_4.h
rename to vendor/blaze/src/convert/rules/upgrade_draft_3_to_draft_4.h
index bb037386..a41ff3dd 100644
--- a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_3_to_draft_4.h
+++ b/vendor/blaze/src/convert/rules/upgrade_draft_3_to_draft_4.h
@@ -1,9 +1,8 @@
 class UpgradeDraft3ToDraft4 final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   UpgradeDraft3ToDraft4()
-      : SchemaTransformRule{"upgrade_draft_3_to_draft_4", ""} {};
+      : SchemaTransformRule{"upgrade_draft_3_to_draft_4"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class UpgradeDraft3ToDraft4 final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(
         vocabularies.contains(SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_3) &&
         schema.is_object());
@@ -44,8 +43,7 @@ class UpgradeDraft3ToDraft4 final : public SchemaTransformRule {
     return true;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     rewrite_type_any(schema);
     rewrite_type_array_with_subschemas(schema);
     rewrite_disallow(schema);
diff --git a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_4_to_draft_6.h b/vendor/blaze/src/convert/rules/upgrade_draft_4_to_draft_6.h
similarity index 97%
rename from vendor/blaze/src/alterschema/upgrade/upgrade_draft_4_to_draft_6.h
rename to vendor/blaze/src/convert/rules/upgrade_draft_4_to_draft_6.h
index 688c00b5..fbbbac6c 100644
--- a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_4_to_draft_6.h
+++ b/vendor/blaze/src/convert/rules/upgrade_draft_4_to_draft_6.h
@@ -1,9 +1,8 @@
 class UpgradeDraft4ToDraft6 final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   UpgradeDraft4ToDraft6()
-      : SchemaTransformRule{"upgrade_draft_4_to_draft_6", ""} {};
+      : SchemaTransformRule{"upgrade_draft_4_to_draft_6"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,9 @@ class UpgradeDraft4ToDraft6 final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
+    this->sanitize_pending_ = false;
+
     ONLY_CONTINUE_IF(
         vocabularies.contains(SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_4) &&
         schema.is_object());
@@ -58,17 +59,12 @@ class UpgradeDraft4ToDraft6 final : public SchemaTransformRule {
       }
     }
 
-    if (sanitization_branch) {
-      return Result{std::vector<sourcemeta::core::Pointer>{},
-                    std::string{"sanitize"}};
-    }
-
+    this->sanitize_pending_ = sanitization_branch;
     return true;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &result) const
-      -> void override {
-    if (result.description.has_value()) {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    if (this->sanitize_pending_) {
       const auto renames{build_resource_rename_map(schema)};
       std::optional<std::string> resource_base;
       if (schema.defines("id") && schema.at("id").is_string()) {
@@ -129,6 +125,8 @@ class UpgradeDraft4ToDraft6 final : public SchemaTransformRule {
   static inline const std::array<std::string_view, 4> PROMOTED_KEYWORDS{
       {"const", "contains", "propertyNames", "examples"}};
 
+  mutable bool sanitize_pending_{false};
+
   static auto
   has_pending_draft_4_pattern(const sourcemeta::core::JSON &subschema) -> bool {
     if (!subschema.is_object()) {
diff --git a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_6_to_draft_7.h b/vendor/blaze/src/convert/rules/upgrade_draft_6_to_draft_7.h
similarity index 92%
rename from vendor/blaze/src/alterschema/upgrade/upgrade_draft_6_to_draft_7.h
rename to vendor/blaze/src/convert/rules/upgrade_draft_6_to_draft_7.h
index f4983dfb..4313edc8 100644
--- a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_6_to_draft_7.h
+++ b/vendor/blaze/src/convert/rules/upgrade_draft_6_to_draft_7.h
@@ -1,9 +1,8 @@
 class UpgradeDraft6ToDraft7 final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   UpgradeDraft6ToDraft7()
-      : SchemaTransformRule{"upgrade_draft_6_to_draft_7", ""} {};
+      : SchemaTransformRule{"upgrade_draft_6_to_draft_7"} {};
 
   [[nodiscard]] auto
   condition(const sourcemeta::core::JSON &schema,
@@ -13,7 +12,7 @@ class UpgradeDraft6ToDraft7 final : public SchemaTransformRule {
             const sourcemeta::core::SchemaFrame::Location &location,
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &, const bool) const
-      -> SchemaTransformRule::Result override {
+      -> bool override {
     ONLY_CONTINUE_IF(
         vocabularies.contains(SchemaVocabularies::Known::JSON_SCHEMA_DRAFT_6) &&
         subschema_at_dialect(schema, location, DRAFT_6_URL));
@@ -31,8 +30,7 @@ class UpgradeDraft6ToDraft7 final : public SchemaTransformRule {
         });
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     if (schema.defines("$schema") && schema.at("$schema").is_string() &&
         schema.at("$schema").to_string() == DRAFT_6_URL) {
       schema.assign("$schema", sourcemeta::core::JSON{DRAFT_7_URL});
diff --git a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_7_to_draft_2019_09.h b/vendor/blaze/src/convert/rules/upgrade_draft_7_to_draft_2019_09.h
similarity index 95%
rename from vendor/blaze/src/alterschema/upgrade/upgrade_draft_7_to_draft_2019_09.h
rename to vendor/blaze/src/convert/rules/upgrade_draft_7_to_draft_2019_09.h
index 4e1e2f78..0ed82597 100644
--- a/vendor/blaze/src/alterschema/upgrade/upgrade_draft_7_to_draft_2019_09.h
+++ b/vendor/blaze/src/convert/rules/upgrade_draft_7_to_draft_2019_09.h
@@ -1,18 +1,18 @@
 class UpgradeDraft7To201909 final : public SchemaTransformRule {
 public:
-  using mutates = std::true_type;
   using reframe_after_transform = std::true_type;
   UpgradeDraft7To201909()
-      : SchemaTransformRule{"upgrade_draft_7_to_2019_09", ""} {};
-
-  [[nodiscard]] auto condition(
-      const sourcemeta::core::JSON &schema, const sourcemeta::core::JSON &root,
-      const sourcemeta::core::SchemaVocabularies &vocabularies,
-      const sourcemeta::core::SchemaFrame &frame,
-      const sourcemeta::core::SchemaFrame::Location &location,
-      const sourcemeta::core::SchemaWalker &,
-      const sourcemeta::core::SchemaResolver &, const bool is_metaschema) const
-      -> SchemaTransformRule::Result override {
+      : SchemaTransformRule{"upgrade_draft_7_to_2019_09"} {};
+
+  [[nodiscard]] auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &root,
+            const sourcemeta::core::SchemaVocabularies &vocabularies,
+            const sourcemeta::core::SchemaFrame &frame,
+            const sourcemeta::core::SchemaFrame::Location &location,
+            const sourcemeta::core::SchemaWalker &,
+            const sourcemeta::core::SchemaResolver &,
+            const bool is_metaschema) const -> bool override {
     this->metaschema_synthesis_pending_ = false;
 
     ONLY_CONTINUE_IF(
@@ -49,8 +49,7 @@ class UpgradeDraft7To201909 final : public SchemaTransformRule {
     return true;
   }
 
-  auto transform(sourcemeta::core::JSON &schema, const Result &) const
-      -> void override {
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
     this->renames_.clear();
     this->prefix_ref_siblings(schema);
     this->split_id_fragment(schema);
@@ -70,7 +69,7 @@ class UpgradeDraft7To201909 final : public SchemaTransformRule {
                                  const sourcemeta::core::Pointer &,
                                  const sourcemeta::core::Pointer &target,
                                  const sourcemeta::core::Pointer &current) const
-      -> sourcemeta::core::Pointer override {
+      -> std::optional<sourcemeta::core::Pointer> override {
     for (const auto &[old_pointer, new_pointer] : this->renames_) {
       const auto result{target.rebase(current.concat(old_pointer),
                                       current.concat(new_pointer))};
diff --git a/vendor/core/CMakeLists.txt b/vendor/core/CMakeLists.txt
index 4ec730d3..8f94b3db 100644
--- a/vendor/core/CMakeLists.txt
+++ b/vendor/core/CMakeLists.txt
@@ -233,7 +233,6 @@ if(SOURCEMETA_CORE_JSONLD)
 endif()
 
 if(SOURCEMETA_CORE_GZIP)
-  find_package(LibDeflate REQUIRED)
   add_subdirectory(src/core/gzip)
 endif()
 
diff --git a/vendor/core/DEPENDENCIES b/vendor/core/DEPENDENCIES
index 0e7ded69..a5810af5 100644
--- a/vendor/core/DEPENDENCIES
+++ b/vendor/core/DEPENDENCIES
@@ -8,7 +8,6 @@ pyca-cryptography https://github.com/pyca/cryptography 9747d06e83764e7f1ea4c04da
 wycheproof https://github.com/C2SP/wycheproof 6d7cccd0fcb1917368579adeeac10fe802f1b521
 pcre2 https://github.com/PCRE2Project/pcre2 pcre2-10.48
 googlebenchmark https://github.com/google/benchmark 378fe693a1ef51500db21b11ff05a8018c5f0e55
-libdeflate https://github.com/ebiggers/libdeflate v1.26
 unicodetools https://github.com/unicode-org/unicodetools final-17.0-20250910
 jose-cookbook https://github.com/ietf-jose/cookbook 13692b68bfc18b99557a5b1ed311fd5077bfff04
 w3c-json-ld https://github.com/w3c/json-ld-api 8654ac22b6cf4f441d2fee915ae634d36b5a8067
@@ -38,3 +37,4 @@ iana-oauth/client-metadata.csv https://www.iana.org/assignments/oauth-parameters
 iana-oauth/uri.csv https://www.iana.org/assignments/oauth-parameters/uri.csv dca1a780e342845d2f3b0fe2391f12faf27217f0234933c1a399e27b55dcadec
 iana-oauth/token-introspection-response.csv https://www.iana.org/assignments/oauth-parameters/token-introspection-response.csv d1a3e84f98853b72f51ed59e99d796bf20c415a8aca13e04373c0a25bbb9b1f4
 iana-oauth/endpoint.csv https://www.iana.org/assignments/oauth-parameters/endpoint.csv 1b5d125a9cfa06ac62286e322449cf369647069a6336483f372fbd1d84ad5aca
+whatwg-html-build https://github.com/whatwg/html-build 283a3531a61106d07d9a7d9fb3e6f3b9bfd33d70
diff --git a/vendor/core/cmake/FindLibDeflate.cmake b/vendor/core/cmake/FindLibDeflate.cmake
deleted file mode 100644
index f5bbcad1..00000000
--- a/vendor/core/cmake/FindLibDeflate.cmake
+++ /dev/null
@@ -1,137 +0,0 @@
-if(NOT LibDeflate_FOUND)
-  set(LIBDEFLATE_DIR "${PROJECT_SOURCE_DIR}/vendor/libdeflate")
-  set(LIBDEFLATE_LIB_DIR "${LIBDEFLATE_DIR}/lib")
-
-  set(LIBDEFLATE_SOURCES
-    "${LIBDEFLATE_LIB_DIR}/utils.c"
-    "${LIBDEFLATE_LIB_DIR}/deflate_compress.c"
-    "${LIBDEFLATE_LIB_DIR}/deflate_decompress.c"
-    "${LIBDEFLATE_LIB_DIR}/gzip_compress.c"
-    "${LIBDEFLATE_LIB_DIR}/gzip_decompress.c"
-    "${LIBDEFLATE_LIB_DIR}/adler32.c"
-    "${LIBDEFLATE_LIB_DIR}/crc32.c"
-    "${LIBDEFLATE_LIB_DIR}/zlib_compress.c"
-    "${LIBDEFLATE_LIB_DIR}/zlib_decompress.c")
-
-  # Platform-specific CPU feature detection
-  if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
-    list(APPEND LIBDEFLATE_SOURCES
-      "${LIBDEFLATE_LIB_DIR}/arm/cpu_features.c")
-  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64|amd64|x86|i[3-6]86")
-    list(APPEND LIBDEFLATE_SOURCES
-      "${LIBDEFLATE_LIB_DIR}/x86/cpu_features.c")
-  endif()
-
-  # Merged into the library that uses it, so that no archive, no header and
-  # no CMake package of our own build of it reaches an installed consumer
-  add_library(libdeflate OBJECT ${LIBDEFLATE_SOURCES})
-  sourcemeta_add_default_options(PRIVATE libdeflate)
-
-  # Check if the assembler supports ARM dot-product (udot) instructions.
-  if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
-    include(CheckCSourceCompiles)
-    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND
-        CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
-      check_c_source_compiles("
-        #include <arm_neon.h>
-        __attribute__((target(\"+dotprod\")))
-        int test(void) {
-          uint32x4_t a = vdupq_n_u32(0);
-          uint8x16_t b = vdupq_n_u8(0);
-          uint8x16_t c = vdupq_n_u8(0);
-          a = vdotq_u32(a, b, c);
-          return (int)vgetq_lane_u32(a, 0);
-        }
-        int main(void) { return test(); }
-      " LIBDEFLATE_HAS_DOTPROD_ASSEMBLER)
-    else()
-      set(LIBDEFLATE_SAVED_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
-      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -march=armv8.2-a+dotprod")
-      check_c_source_compiles("
-        #include <arm_neon.h>
-        int main(void) {
-          uint32x4_t a = vdupq_n_u32(0);
-          uint8x16_t b = vdupq_n_u8(0);
-          uint8x16_t c = vdupq_n_u8(0);
-          a = vdotq_u32(a, b, c);
-          return 0;
-        }
-      " LIBDEFLATE_HAS_DOTPROD_ASSEMBLER)
-      set(CMAKE_REQUIRED_FLAGS "${LIBDEFLATE_SAVED_CMAKE_REQUIRED_FLAGS}")
-    endif()
-    if(NOT LIBDEFLATE_HAS_DOTPROD_ASSEMBLER)
-      target_compile_definitions(libdeflate PRIVATE
-        LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_DOTPROD)
-    endif()
-
-    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" AND
-        CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
-      check_c_source_compiles("
-        #include <arm_neon.h>
-        __attribute__((target(\"+crypto,+crc,+sha3\")))
-        int test(void) {
-          uint8x16_t a = vdupq_n_u8(0);
-          uint8x16_t b = vdupq_n_u8(0);
-          uint8x16_t c = vdupq_n_u8(0);
-          a = veor3q_u8(a, b, c);
-          return (int)vgetq_lane_u8(a, 0);
-        }
-        int main(void) { return test(); }
-      " LIBDEFLATE_HAS_SHA3_ASSEMBLER)
-    else()
-      set(LIBDEFLATE_SAVED_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
-      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -march=armv8.2-a+crypto+crc+sha3")
-      check_c_source_compiles("
-        #include <arm_neon.h>
-        int main(void) {
-          uint8x16_t a = vdupq_n_u8(0);
-          uint8x16_t b = vdupq_n_u8(0);
-          uint8x16_t c = vdupq_n_u8(0);
-          a = veor3q_u8(a, b, c);
-          return 0;
-        }
-      " LIBDEFLATE_HAS_SHA3_ASSEMBLER)
-      set(CMAKE_REQUIRED_FLAGS "${LIBDEFLATE_SAVED_CMAKE_REQUIRED_FLAGS}")
-    endif()
-    if(NOT LIBDEFLATE_HAS_SHA3_ASSEMBLER)
-      target_compile_definitions(libdeflate PRIVATE
-        LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_SHA3)
-    endif()
-  endif()
-
-  target_include_directories(libdeflate PUBLIC
-    "$<BUILD_INTERFACE:${LIBDEFLATE_DIR}>")
-
-  target_include_directories(libdeflate PRIVATE
-    "${LIBDEFLATE_LIB_DIR}")
-
-  # Marking every entry point as visible would publish this library from the
-  # one it is merged into, where it can collide with a real installation of it
-  target_compile_definitions(libdeflate PRIVATE LIBDEFLATE_EXPORT_SYM=)
-
-  # The processor feature detection this library performs on Linux reaches for
-  # interfaces that the C library only declares outside the strict ISO mode
-  # this project otherwise compiles C in
-  if(SOURCEMETA_OS_LINUX)
-    target_compile_definitions(libdeflate PRIVATE _GNU_SOURCE)
-  endif()
-
-  if(SOURCEMETA_COMPILER_LLVM OR SOURCEMETA_COMPILER_GCC)
-    target_compile_options(libdeflate PRIVATE -Wno-conversion)
-    target_compile_options(libdeflate PRIVATE -Wno-sign-conversion)
-    target_compile_options(libdeflate PRIVATE -Wno-sign-compare)
-    target_compile_options(libdeflate PRIVATE -Wno-implicit-int-conversion)
-    target_compile_options(libdeflate PRIVATE -Wno-shorten-64-to-32)
-    target_compile_options(libdeflate PRIVATE -Wno-unused-parameter)
-  endif()
-
-  if(SOURCEMETA_COMPILER_MSVC)
-    target_compile_options(libdeflate PRIVATE /wd4113)
-    target_compile_options(libdeflate PRIVATE /wd4244)
-    target_compile_options(libdeflate PRIVATE /wd4267)
-  endif()
-
-  add_library(LibDeflate::LibDeflate ALIAS libdeflate)
-
-  set(LibDeflate_FOUND ON)
-endif()
diff --git a/vendor/core/cmake/common/compiler/simd.cmake b/vendor/core/cmake/common/compiler/simd.cmake
index f213a4f3..cdd2fa37 100644
--- a/vendor/core/cmake/common/compiler/simd.cmake
+++ b/vendor/core/cmake/common/compiler/simd.cmake
@@ -16,6 +16,12 @@ macro(sourcemeta_enable_simd)
       if(COMPILER_SUPPORTS_AVX2)
         message(STATUS "Enabling SIMD AVX2")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2")
+        # Every processor with AVX2 also has carry-less multiplication
+        check_cxx_compiler_flag("-mpclmul" COMPILER_SUPPORTS_PCLMUL)
+        if(COMPILER_SUPPORTS_PCLMUL)
+          message(STATUS "Enabling SIMD PCLMUL")
+          set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mpclmul")
+        endif()
       else()
         check_cxx_compiler_flag("-msse4.2" COMPILER_SUPPORTS_SSE42)
         if(COMPILER_SUPPORTS_SSE42)
@@ -31,19 +37,21 @@ macro(sourcemeta_enable_simd)
       endif()
     endif()
   elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64" AND NOT MSVC)
-    # +crc is part of the optional Armv8.0-A CRC32 extension. It is
+    # +crc is part of the optional Armv8.0-A CRC32 extension, and +crypto
+    # brings the carry-less multiplication instructions. Both are
     # guaranteed on Apple Silicon (Armv8.5+) and several other modern cores,
-    # but Cortex-A53-class CPUs do not have it. The compiler accepting the
-    # flag does not prove the runtime CPU supports the instruction, so the
-    # only platform we auto-enable +crc on is Apple Silicon. Other aarch64
+    # but Cortex-A53-class CPUs may lack them. The compiler accepting the
+    # flags does not prove the runtime CPU supports the instructions, so the
+    # only platform we auto-enable them on is Apple Silicon. Other aarch64
     # targets keep the plain NEON baseline and the CRC32 software fallback.
     set(SIMD_NEON_FLAG_APPLIED FALSE)
     if(APPLE)
-      check_cxx_compiler_flag("-march=armv8-a+fp+simd+crc"
-        COMPILER_SUPPORTS_NEON_CRC)
-      if(COMPILER_SUPPORTS_NEON_CRC)
-        message(STATUS "Enabling SIMD NEON + CRC32")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8-a+fp+simd+crc")
+      check_cxx_compiler_flag("-march=armv8-a+fp+simd+crc+crypto"
+        COMPILER_SUPPORTS_NEON_CRC_CRYPTO)
+      if(COMPILER_SUPPORTS_NEON_CRC_CRYPTO)
+        message(STATUS "Enabling SIMD NEON + CRC32 + Crypto")
+        set(CMAKE_CXX_FLAGS
+          "${CMAKE_CXX_FLAGS} -march=armv8-a+fp+simd+crc+crypto")
         set(SIMD_NEON_FLAG_APPLIED TRUE)
       endif()
     endif()
diff --git a/vendor/core/config.cmake.in b/vendor/core/config.cmake.in
index e7a9d88b..189f0c87 100644
--- a/vendor/core/config.cmake.in
+++ b/vendor/core/config.cmake.in
@@ -352,6 +352,7 @@ foreach(component ${SOURCEMETA_CORE_COMPONENTS})
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_text.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_css.cmake")
   elseif(component STREQUAL "markdown")
+    include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_unicode.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_markdown.cmake")
   elseif(component STREQUAL "diff")
     include("${CMAKE_CURRENT_LIST_DIR}/sourcemeta_core_text.cmake")
diff --git a/vendor/core/src/core/crypto/CMakeLists.txt b/vendor/core/src/core/crypto/CMakeLists.txt
index 005269cf..217f21d4 100644
--- a/vendor/core/src/core/crypto/CMakeLists.txt
+++ b/vendor/core/src/core/crypto/CMakeLists.txt
@@ -28,7 +28,7 @@ if(SOURCEMETA_CORE_CRYPTO_USE_SYSTEM_OPENSSL)
     crypto_sign_openssl.cc crypto_aes_gcm_openssl.cc crypto_aes_cbc_openssl.cc
     crypto_aes_kw_openssl.cc crypto_rsa_oaep_openssl.cc crypto_ecdh_openssl.cc
     crypto_hkdf_openssl.cc
-    crypto_openssl.h crypto_pkcs8.h)
+    crypto_openssl.h crypto_pkcs8.h crypto_system.h)
   target_link_libraries(sourcemeta_core_crypto PRIVATE OpenSSL::Crypto)
 elseif(APPLE)
   enable_language(OBJCXX)
@@ -123,7 +123,7 @@ elseif(APPLE)
     crypto_eddsa_cryptokit.mm "${CRYPTOKIT_OBJECT}"
     crypto_eddsa.h crypto_eddsa_apple.h crypto_apple.h crypto_aes_apple.h
     crypto_kdf_apple.h
-    crypto_bignum.h crypto_shake256.h crypto_pkcs8.h)
+    crypto_bignum.h crypto_shake256.h crypto_pkcs8.h crypto_system.h)
 
   # The generated Objective-C interface header lives in the build tree
   target_include_directories(sourcemeta_core_crypto
@@ -170,7 +170,8 @@ elseif(WIN32)
     crypto_hkdf_windows.cc
     crypto_eddsa.h
     crypto_windows.h crypto_aes_kw_loop.h
-    crypto_bignum.h crypto_ecc.h crypto_shake256.h crypto_pkcs8.h)
+    crypto_bignum.h crypto_ecc.h crypto_shake256.h crypto_pkcs8.h
+    crypto_system.h)
 
   # The raw secret agreement and the key derivation provider are declared from
   # Windows 10 version 1803 onwards, and the headers hide both unless the
@@ -192,7 +193,7 @@ else()
     crypto_rsa_oaep_other.cc crypto_ecdh_other.cc crypto_hkdf_other.cc
     crypto_aes_block.h crypto_aes_kw_loop.h crypto_sha1_other.h
     crypto_bignum.h crypto_ecc.h crypto_eddsa.h crypto_shake256.h
-    crypto_pkcs8.h crypto_other.h)
+    crypto_pkcs8.h crypto_other.h crypto_rsa_other.h)
 endif()
 
 if(SOURCEMETA_CORE_INSTALL)
diff --git a/vendor/core/src/core/crypto/crypto_base64.cc b/vendor/core/src/core/crypto/crypto_base64.cc
index 7a314e1e..95986320 100644
--- a/vendor/core/src/core/crypto/crypto_base64.cc
+++ b/vendor/core/src/core/crypto/crypto_base64.cc
@@ -21,21 +21,54 @@ constexpr std::string_view BASE64URL_ALPHABET{
 
 constexpr std::uint8_t INVALID_SEXTET{0xFF};
 
-constexpr auto build_decode_table(const std::string_view alphabet) noexcept
-    -> std::array<std::uint8_t, 256> {
-  std::array<std::uint8_t, 256> table{};
-  table.fill(INVALID_SEXTET);
-  for (std::size_t index = 0; index < alphabet.size(); ++index) {
-    table[static_cast<std::uint8_t>(alphabet[index])] =
-        static_cast<std::uint8_t>(index);
-  }
-  return table;
-}
-
+// The inverse of each alphabet, mapping every octet to the sextet it denotes,
+// or to the invalid sextet when the octet is not part of that alphabet
 constexpr std::array<std::uint8_t, 256> BASE64_DECODE_TABLE{
-    build_decode_table(BASE64_ALPHABET)};
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xFF, 0xFF, 0x3F,
+     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+     0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
+     0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
+     0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
+     0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF}};
 constexpr std::array<std::uint8_t, 256> BASE64URL_DECODE_TABLE{
-    build_decode_table(BASE64URL_ALPHABET)};
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0xFF,
+     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+     0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
+     0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F,
+     0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
+     0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
+     0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF}};
 
 template <typename Output>
 auto encode(const std::string_view input, const std::string_view alphabet,
diff --git a/vendor/core/src/core/crypto/crypto_bignum.h b/vendor/core/src/core/crypto/crypto_bignum.h
index f5d6fd87..af97021b 100644
--- a/vendor/core/src/core/crypto/crypto_bignum.h
+++ b/vendor/core/src/core/crypto/crypto_bignum.h
@@ -2,18 +2,19 @@
 #define SOURCEMETA_CORE_CRYPTO_BIGNUM_H_
 
 // Fixed-capacity unsigned big integer arithmetic for the reference signature
-// backend. Capacity fits 4096-bit RSA operands and their double-width products.
+// backend, with one capacity sized for RSA and a smaller one for the curves.
 // The verification paths consume only public inputs and stay variable time; the
 // signing paths use the constant-time layer below (fixed-width multiply,
-// Barrett reduction, masked select and inverse) on their secret operands. Only
-// the Barrett context precompute stays variable time, and it touches the public
-// modulus alone
+// Barrett reduction, masked select and inverse) on their secret operands. The
+// Barrett context precompute stays variable time for a public modulus, and has
+// a constant-time form for the secret prime factors of an RSA key
 
 #include <sourcemeta/core/numeric.h>
 #include <sourcemeta/core/text.h>
 
 #include <algorithm>   // std::max, std::min
 #include <array>       // std::array
+#include <bit>         // std::bit_width
 #include <cstddef>     // std::size_t
 #include <cstdint>     // std::uint8_t, std::uint64_t
 #include <optional>    // std::optional
@@ -24,18 +25,29 @@ namespace sourcemeta::core {
 
 using BignumDoubleWord = uint128_t;
 
-struct Bignum {
-  // Enough words for an 8192-bit product plus shifting headroom
-  static constexpr std::size_t CAPACITY{130};
-  std::array<std::uint64_t, CAPACITY> words{};
+template <std::size_t Capacity> struct BasicBignum {
+  static constexpr std::size_t CAPACITY{Capacity};
+  std::array<std::uint64_t, Capacity> words{};
   std::size_t size{0};
 };
 
+// Enough words for an 8192-bit product plus shifting headroom
+inline constexpr std::size_t BIGNUM_CAPACITY{130};
+using Bignum = BasicBignum<BIGNUM_CAPACITY>;
+
+// Enough words for the double-width products of the largest curve field, P-521
+// at nine words, for the Barrett estimates built on them, and for the 114-octet
+// Ed448 digest, so the curve routines do not zero and copy the RSA capacity on
+// every temporary
+inline constexpr std::size_t CURVE_BIGNUM_CAPACITY{32};
+using CurveBignum = BasicBignum<CURVE_BIGNUM_CAPACITY>;
+
 // Overwrite the whole word buffer of a big integer that held secret material,
 // including the words past the current size that intermediate operations wrote,
 // so it does not linger in freed memory. The volatile access stops the compiler
 // from eliding the write as a dead store
-inline auto secure_zero(Bignum &value) noexcept -> void {
+template <std::size_t Capacity>
+inline auto secure_zero(BasicBignum<Capacity> &value) noexcept -> void {
   auto *pointer{reinterpret_cast<volatile unsigned char *>(value.words.data())};
   for (std::size_t index{0}; index < sizeof(value.words); index += 1) {
     pointer[index] = 0;
@@ -47,29 +59,34 @@ inline auto secure_zero(Bignum &value) noexcept -> void {
 // Overwrite the referenced big integer when leaving the current scope, so a
 // secret value a local holds is wiped across every return path without
 // threading a manual call through each one
-struct SecureBignumScope {
-  explicit SecureBignumScope(Bignum &value) noexcept : target{value} {}
+template <std::size_t Capacity> struct SecureBignumScope {
+  explicit SecureBignumScope(BasicBignum<Capacity> &value) noexcept
+      : target{value} {}
   SecureBignumScope(const SecureBignumScope &) = delete;
   auto operator=(const SecureBignumScope &) -> SecureBignumScope & = delete;
   SecureBignumScope(SecureBignumScope &&) = delete;
   auto operator=(SecureBignumScope &&) -> SecureBignumScope & = delete;
   ~SecureBignumScope() { secure_zero(this->target); }
-  Bignum &target;
+  BasicBignum<Capacity> &target;
 };
 
-inline auto bignum_normalize(Bignum &value) noexcept -> void {
-  while (value.size > 0 && value.words[value.size - 1] == 0) {
+template <std::size_t Capacity>
+inline auto bignum_normalize(BasicBignum<Capacity> &value) noexcept -> void {
+  const auto *value_data{value.words.data()};
+  while (value.size > 0 && value_data[value.size - 1] == 0) {
     value.size -= 1;
   }
 }
 
-inline auto bignum_from_bytes(const std::string_view input) noexcept -> Bignum {
-  Bignum result;
+template <std::size_t Capacity = BIGNUM_CAPACITY>
+inline auto bignum_from_bytes(const std::string_view input) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
   std::size_t bytes_consumed{0};
   for (std::size_t index = input.size(); index > 0; --index) {
     const auto byte{static_cast<std::uint8_t>(input[index - 1])};
     const auto word_index{bytes_consumed / 8};
-    if (word_index >= Bignum::CAPACITY) {
+    if (word_index >= Capacity) {
       break;
     }
 
@@ -83,8 +100,10 @@ inline auto bignum_from_bytes(const std::string_view input) noexcept -> Bignum {
   return result;
 }
 
-inline auto bignum_from_u64(const std::uint64_t value) noexcept -> Bignum {
-  Bignum result;
+template <std::size_t Capacity = BIGNUM_CAPACITY>
+inline auto bignum_from_u64(const std::uint64_t value) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
   if (value > 0) {
     result.words[0] = value;
     result.size = 1;
@@ -93,52 +112,56 @@ inline auto bignum_from_u64(const std::uint64_t value) noexcept -> Bignum {
   return result;
 }
 
-inline auto bignum_from_hex(const std::string_view hex) -> Bignum {
+template <std::size_t Capacity = BIGNUM_CAPACITY>
+inline auto bignum_from_hex(const std::string_view hex)
+    -> BasicBignum<Capacity> {
   // An odd length is decoded as if a zero nibble had been prepended
   const auto bytes{hex_to_bytes(hex, true)};
   if (!bytes.has_value()) {
-    return Bignum{};
+    return BasicBignum<Capacity>{};
   }
 
-  return bignum_from_bytes(bytes.value());
+  return bignum_from_bytes<Capacity>(bytes.value());
 }
 
-inline auto bignum_is_zero(const Bignum &value) noexcept -> bool {
+template <std::size_t Capacity>
+inline auto bignum_is_zero(const BasicBignum<Capacity> &value) noexcept
+    -> bool {
   return value.size == 0;
 }
 
-inline auto bignum_compare(const Bignum &left, const Bignum &right) noexcept
-    -> int {
+template <std::size_t Capacity>
+inline auto bignum_compare(const BasicBignum<Capacity> &left,
+                           const BasicBignum<Capacity> &right) noexcept -> int {
   if (left.size != right.size) {
     return left.size < right.size ? -1 : 1;
   }
 
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
   for (std::size_t index = left.size; index > 0; --index) {
-    if (left.words[index - 1] != right.words[index - 1]) {
-      return left.words[index - 1] < right.words[index - 1] ? -1 : 1;
+    if (left_data[index - 1] != right_data[index - 1]) {
+      return left_data[index - 1] < right_data[index - 1] ? -1 : 1;
     }
   }
 
   return 0;
 }
 
-inline auto bignum_bit_length(const Bignum &value) noexcept -> std::size_t {
+template <std::size_t Capacity>
+inline auto bignum_bit_length(const BasicBignum<Capacity> &value) noexcept
+    -> std::size_t {
   if (value.size == 0) {
     return 0;
   }
 
-  auto top_word{value.words[value.size - 1]};
-  std::size_t top_bits{0};
-  while (top_word > 0) {
-    top_word >>= 1U;
-    top_bits += 1;
-  }
-
-  return ((value.size - 1) * 64) + top_bits;
+  return ((value.size - 1) * 64) +
+         static_cast<std::size_t>(std::bit_width(value.words[value.size - 1]));
 }
 
-inline auto bignum_get_bit(const Bignum &value, const std::size_t bit) noexcept
-    -> bool {
+template <std::size_t Capacity>
+inline auto bignum_get_bit(const BasicBignum<Capacity> &value,
+                           const std::size_t bit) noexcept -> bool {
   const auto word{bit / 64};
   if (word >= value.size) {
     return false;
@@ -150,31 +173,35 @@ inline auto bignum_get_bit(const Bignum &value, const std::size_t bit) noexcept
 // The same read without the size-dependent early return, so the signing ladders
 // do not reveal the secret scalar's length through the branch. The bit index is
 // bounded by the public curve size, so the guard is on public data
-inline auto bignum_get_bit_fixed(const Bignum &value,
+template <std::size_t Capacity>
+inline auto bignum_get_bit_fixed(const BasicBignum<Capacity> &value,
                                  const std::size_t bit) noexcept -> bool {
   const auto word{bit / 64};
-  return word < Bignum::CAPACITY &&
-         ((value.words[word] >> (bit % 64)) & 1U) != 0;
+  return word < Capacity && ((value.words[word] >> (bit % 64)) & 1U) != 0;
 }
 
 // Assumes the result fits in the capacity
-inline auto bignum_shift_left(const Bignum &value,
-                              const std::size_t bits) noexcept -> Bignum {
-  Bignum result;
+template <std::size_t Capacity>
+inline auto bignum_shift_left(const BasicBignum<Capacity> &value,
+                              const std::size_t bits) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
   const auto word_shift{bits / 64};
   const auto bit_shift{bits % 64};
   result.size = value.size + word_shift + 1;
-  result.size = std::min(result.size, Bignum::CAPACITY);
+  result.size = std::min(result.size, Capacity);
 
+  const auto *value_data{value.words.data()};
+  auto *result_data{result.words.data()};
   for (std::size_t index = 0; index < value.size; ++index) {
     const auto destination{index + word_shift};
-    if (destination >= Bignum::CAPACITY) {
+    if (destination >= Capacity) {
       break;
     }
 
-    result.words[destination] |= value.words[index] << bit_shift;
-    if (bit_shift > 0 && destination + 1 < Bignum::CAPACITY) {
-      result.words[destination + 1] |= value.words[index] >> (64U - bit_shift);
+    result_data[destination] |= value_data[index] << bit_shift;
+    if (bit_shift > 0 && destination + 1 < Capacity) {
+      result_data[destination + 1] |= value_data[index] >> (64U - bit_shift);
     }
   }
 
@@ -183,13 +210,17 @@ inline auto bignum_shift_left(const Bignum &value,
 }
 
 // Assumes the left operand is greater than or equal to the right one
-inline auto bignum_subtract_in_place(Bignum &left, const Bignum &right) noexcept
-    -> void {
+template <std::size_t Capacity>
+inline auto
+bignum_subtract_in_place(BasicBignum<Capacity> &left,
+                         const BasicBignum<Capacity> &right) noexcept -> void {
+  auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
   std::uint64_t borrow{0};
   for (std::size_t index = 0; index < left.size; ++index) {
-    const auto subtrahend{index < right.size ? right.words[index] : 0};
-    const auto previous{left.words[index]};
-    left.words[index] = previous - subtrahend - borrow;
+    const auto subtrahend{index < right.size ? right_data[index] : 0};
+    const auto previous{left_data[index]};
+    left_data[index] = previous - subtrahend - borrow;
     borrow = (previous < subtrahend || (borrow == 1 && previous == subtrahend))
                  ? 1
                  : 0;
@@ -198,14 +229,18 @@ inline auto bignum_subtract_in_place(Bignum &left, const Bignum &right) noexcept
   bignum_normalize(left);
 }
 
-inline auto bignum_shift_right(const Bignum &value,
-                               const std::size_t bits) noexcept -> Bignum;
+template <std::size_t Capacity>
+inline auto bignum_shift_right(const BasicBignum<Capacity> &value,
+                               const std::size_t bits) noexcept
+    -> BasicBignum<Capacity>;
 
 // Reduce a value modulo the modulus with Knuth's Algorithm D (TAOCP Volume 2,
 // Section 4.3.1), the schoolbook long division that estimates one quotient
 // word per step rather than one bit, so the cost is quadratic in the number of
 // words rather than the number of bits
-inline auto bignum_reduce(Bignum &value, const Bignum &modulus) noexcept
+template <std::size_t Capacity>
+inline auto bignum_reduce(BasicBignum<Capacity> &value,
+                          const BasicBignum<Capacity> &modulus) noexcept
     -> void {
   if (bignum_compare(value, modulus) < 0) {
     return;
@@ -222,13 +257,14 @@ inline auto bignum_reduce(Bignum &value, const Bignum &modulus) noexcept
   // A single-word divisor folds the value down word by word
   if (divisor_words == 1) {
     const auto divisor{modulus.words[0]};
+    const auto *value_data{value.words.data()};
     BignumDoubleWord remainder{0};
     for (std::size_t index = value.size; index > 0; --index) {
-      remainder = (remainder << 64U) | value.words[index - 1];
+      remainder = (remainder << 64U) | value_data[index - 1];
       remainder %= divisor;
     }
 
-    value = bignum_from_u64(static_cast<std::uint64_t>(remainder));
+    value = bignum_from_u64<Capacity>(static_cast<std::uint64_t>(remainder));
     return;
   }
 
@@ -238,10 +274,12 @@ inline auto bignum_reduce(Bignum &value, const Bignum &modulus) noexcept
       (64U - (bignum_bit_length(modulus) % 64U)) % 64U)};
   const auto divisor{shift > 0 ? bignum_shift_left(modulus, shift) : modulus};
   auto dividend{shift > 0 ? bignum_shift_left(value, shift) : value};
+  const auto *divisor_data{divisor.words.data()};
+  auto *dividend_data{dividend.words.data()};
   const auto dividend_words{dividend.size};
   const auto quotient_words{dividend_words - divisor_words};
-  const auto top{divisor.words[divisor_words - 1]};
-  const auto next{divisor.words[divisor_words - 2]};
+  const auto top{divisor_data[divisor_words - 1]};
+  const auto next{divisor_data[divisor_words - 2]};
   const BignumDoubleWord base{static_cast<BignumDoubleWord>(1) << 64U};
 
   for (std::size_t step = quotient_words + 1; step > 0; --step) {
@@ -249,14 +287,14 @@ inline auto bignum_reduce(Bignum &value, const Bignum &modulus) noexcept
 
     // Estimate the quotient word from the top two words of the running value
     const auto numerator{
-        (static_cast<BignumDoubleWord>(dividend.words[offset + divisor_words])
+        (static_cast<BignumDoubleWord>(dividend_data[offset + divisor_words])
          << 64U) |
-        dividend.words[offset + divisor_words - 1]};
+        dividend_data[offset + divisor_words - 1]};
     auto estimate{numerator / top};
-    auto estimate_remainder{numerator % top};
+    auto estimate_remainder{numerator - (estimate * top)};
     while (estimate >= base ||
            estimate * next > (estimate_remainder << 64U) +
-                                 dividend.words[offset + divisor_words - 2]) {
+                                 dividend_data[offset + divisor_words - 2]) {
       estimate -= 1;
       estimate_remainder += top;
       if (estimate_remainder >= base) {
@@ -266,34 +304,27 @@ inline auto bignum_reduce(Bignum &value, const Bignum &modulus) noexcept
 
     // Multiply the divisor by the estimate and subtract from the running value
     const auto quotient_word{static_cast<std::uint64_t>(estimate)};
-    BignumDoubleWord carry{0};
+    std::uint64_t carry{0};
     std::uint64_t borrow{0};
     for (std::size_t index = 0; index < divisor_words; ++index) {
-      const auto product{(static_cast<BignumDoubleWord>(quotient_word) *
-                          divisor.words[index]) +
-                         carry};
-      carry = product >> 64U;
-      const auto subtrahend{static_cast<std::uint64_t>(product)};
-      const auto current{dividend.words[offset + index]};
-      const auto without_subtrahend{current - subtrahend};
-      auto next_borrow{current < subtrahend ? 1U : 0U};
-      const auto result_word{without_subtrahend - borrow};
-      if (without_subtrahend < borrow) {
-        next_borrow += 1U;
-      }
-
-      dividend.words[offset + index] = result_word;
-      borrow = next_borrow;
+      const auto product{
+          (static_cast<BignumDoubleWord>(quotient_word) * divisor_data[index]) +
+          carry};
+      carry = static_cast<std::uint64_t>(product >> 64U);
+      const auto difference{
+          static_cast<BignumDoubleWord>(dividend_data[offset + index]) -
+          static_cast<std::uint64_t>(product) - borrow};
+      dividend_data[offset + index] = static_cast<std::uint64_t>(difference);
+      borrow = static_cast<std::uint64_t>(difference >> 64U) & 1U;
     }
 
-    const auto current{dividend.words[offset + divisor_words]};
-    const auto subtrahend{static_cast<std::uint64_t>(carry)};
-    const auto without_subtrahend{current - subtrahend};
-    auto next_borrow{current < subtrahend ? 1U : 0U};
-    dividend.words[offset + divisor_words] = without_subtrahend - borrow;
-    if (without_subtrahend < borrow) {
-      next_borrow += 1U;
-    }
+    const auto top_difference{
+        static_cast<BignumDoubleWord>(dividend_data[offset + divisor_words]) -
+        carry - borrow};
+    dividend_data[offset + divisor_words] =
+        static_cast<std::uint64_t>(top_difference);
+    const auto next_borrow{static_cast<std::uint64_t>(top_difference >> 64U) &
+                           1U};
 
     // The estimate was at most one too large, so add the divisor back when the
     // subtraction borrowed past the top
@@ -301,13 +332,13 @@ inline auto bignum_reduce(Bignum &value, const Bignum &modulus) noexcept
       BignumDoubleWord add_carry{0};
       for (std::size_t index = 0; index < divisor_words; ++index) {
         const auto sum{
-            static_cast<BignumDoubleWord>(dividend.words[offset + index]) +
-            divisor.words[index] + add_carry};
-        dividend.words[offset + index] = static_cast<std::uint64_t>(sum);
+            static_cast<BignumDoubleWord>(dividend_data[offset + index]) +
+            divisor_data[index] + add_carry};
+        dividend_data[offset + index] = static_cast<std::uint64_t>(sum);
         add_carry = sum >> 64U;
       }
 
-      dividend.words[offset + divisor_words] +=
+      dividend_data[offset + divisor_words] +=
           static_cast<std::uint64_t>(add_carry);
     }
   }
@@ -319,31 +350,33 @@ inline auto bignum_reduce(Bignum &value, const Bignum &modulus) noexcept
 }
 
 // Assumes both operands fit in half the capacity
-inline auto bignum_multiply(const Bignum &left, const Bignum &right) noexcept
-    -> Bignum {
-  Bignum result;
+template <std::size_t Capacity>
+inline auto bignum_multiply(const BasicBignum<Capacity> &left,
+                            const BasicBignum<Capacity> &right) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
   result.size = left.size + right.size;
-  result.size = std::min(result.size, Bignum::CAPACITY);
+  result.size = std::min(result.size, Capacity);
 
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
+  auto *result_data{result.words.data()};
   for (std::size_t left_index = 0; left_index < left.size; ++left_index) {
+    const auto left_word{left_data[left_index]};
+    const auto columns{std::min(right.size, Capacity - left_index)};
     std::uint64_t carry{0};
-    for (std::size_t right_index = 0; right_index < right.size; ++right_index) {
+    for (std::size_t right_index = 0; right_index < columns; ++right_index) {
       const auto destination{left_index + right_index};
-      if (destination >= Bignum::CAPACITY) {
-        break;
-      }
-
       const auto product{
-          (static_cast<BignumDoubleWord>(left.words[left_index]) *
-           right.words[right_index]) +
-          result.words[destination] + carry};
-      result.words[destination] = static_cast<std::uint64_t>(product);
+          (static_cast<BignumDoubleWord>(left_word) * right_data[right_index]) +
+          result_data[destination] + carry};
+      result_data[destination] = static_cast<std::uint64_t>(product);
       carry = static_cast<std::uint64_t>(product >> 64U);
     }
 
     const auto carry_destination{left_index + right.size};
-    if (carry_destination < Bignum::CAPACITY) {
-      result.words[carry_destination] += carry;
+    if (carry_destination < Capacity) {
+      result_data[carry_destination] += carry;
     }
   }
 
@@ -351,9 +384,12 @@ inline auto bignum_multiply(const Bignum &left, const Bignum &right) noexcept
   return result;
 }
 
-inline auto bignum_mod_exp(const Bignum &base, const Bignum &exponent,
-                           const Bignum &modulus) noexcept -> Bignum {
-  Bignum result;
+template <std::size_t Capacity>
+inline auto bignum_mod_exp(const BasicBignum<Capacity> &base,
+                           const BasicBignum<Capacity> &exponent,
+                           const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
   result.words[0] = 1;
   result.size = 1;
 
@@ -362,7 +398,8 @@ inline auto bignum_mod_exp(const Bignum &base, const Bignum &exponent,
 
   const auto exponent_bits{bignum_bit_length(exponent)};
   for (std::size_t index = exponent_bits; index > 0; --index) {
-    result = bignum_multiply(result, result);
+    result = bignum_square_fixed(result, result.size);
+    bignum_normalize(result);
     bignum_reduce(result, modulus);
     if (bignum_get_bit(exponent, index - 1)) {
       result = bignum_multiply(result, reduced_base);
@@ -373,22 +410,27 @@ inline auto bignum_mod_exp(const Bignum &base, const Bignum &exponent,
   return result;
 }
 
-inline auto bignum_add(const Bignum &left, const Bignum &right) noexcept
-    -> Bignum {
-  Bignum result;
+template <std::size_t Capacity>
+inline auto bignum_add(const BasicBignum<Capacity> &left,
+                       const BasicBignum<Capacity> &right) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
   const auto larger{left.size > right.size ? left.size : right.size};
   std::uint64_t carry{0};
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
+  auto *result_data{result.words.data()};
   for (std::size_t index = 0; index < larger; ++index) {
-    const auto first{index < left.size ? left.words[index] : 0};
-    const auto second{index < right.size ? right.words[index] : 0};
+    const auto first{index < left.size ? left_data[index] : 0};
+    const auto second{index < right.size ? right_data[index] : 0};
     const auto sum{static_cast<BignumDoubleWord>(first) + second + carry};
-    result.words[index] = static_cast<std::uint64_t>(sum);
+    result_data[index] = static_cast<std::uint64_t>(sum);
     carry = static_cast<std::uint64_t>(sum >> 64U);
   }
 
   result.size = larger;
-  if (carry > 0 && larger < Bignum::CAPACITY) {
-    result.words[larger] = carry;
+  if (carry > 0 && larger < Capacity) {
+    result_data[larger] = carry;
     result.size = larger + 1;
   }
 
@@ -396,9 +438,11 @@ inline auto bignum_add(const Bignum &left, const Bignum &right) noexcept
   return result;
 }
 
-inline auto bignum_shift_right(const Bignum &value,
-                               const std::size_t bits) noexcept -> Bignum {
-  Bignum result;
+template <std::size_t Capacity>
+inline auto bignum_shift_right(const BasicBignum<Capacity> &value,
+                               const std::size_t bits) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
   const auto word_shift{bits / 64};
   const auto bit_shift{bits % 64};
   if (word_shift >= value.size) {
@@ -406,13 +450,15 @@ inline auto bignum_shift_right(const Bignum &value,
   }
 
   result.size = value.size - word_shift;
+  const auto *value_data{value.words.data()};
+  auto *result_data{result.words.data()};
   for (std::size_t index = 0; index < result.size; ++index) {
-    auto word{value.words[index + word_shift] >> bit_shift};
+    auto word{value_data[index + word_shift] >> bit_shift};
     if (bit_shift > 0 && index + word_shift + 1 < value.size) {
-      word |= value.words[index + word_shift + 1] << (64U - bit_shift);
+      word |= value_data[index + word_shift + 1] << (64U - bit_shift);
     }
 
-    result.words[index] = word;
+    result_data[index] = word;
   }
 
   bignum_normalize(result);
@@ -422,8 +468,11 @@ inline auto bignum_shift_right(const Bignum &value,
 // All modular helpers below assume their operands are already reduced to
 // less than the modulus, as the elliptic curve routines guarantee
 
-inline auto bignum_mod_add(const Bignum &left, const Bignum &right,
-                           const Bignum &modulus) noexcept -> Bignum {
+template <std::size_t Capacity>
+inline auto bignum_mod_add(const BasicBignum<Capacity> &left,
+                           const BasicBignum<Capacity> &right,
+                           const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBignum<Capacity> {
   auto result{bignum_add(left, right)};
   if (bignum_compare(result, modulus) >= 0) {
     bignum_subtract_in_place(result, modulus);
@@ -432,8 +481,11 @@ inline auto bignum_mod_add(const Bignum &left, const Bignum &right,
   return result;
 }
 
-inline auto bignum_mod_subtract(const Bignum &left, const Bignum &right,
-                                const Bignum &modulus) noexcept -> Bignum {
+template <std::size_t Capacity>
+inline auto bignum_mod_subtract(const BasicBignum<Capacity> &left,
+                                const BasicBignum<Capacity> &right,
+                                const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBignum<Capacity> {
   if (bignum_compare(left, right) >= 0) {
     auto result{left};
     bignum_subtract_in_place(result, right);
@@ -445,8 +497,11 @@ inline auto bignum_mod_subtract(const Bignum &left, const Bignum &right,
   return result;
 }
 
-inline auto bignum_mod_multiply(const Bignum &left, const Bignum &right,
-                                const Bignum &modulus) noexcept -> Bignum {
+template <std::size_t Capacity>
+inline auto bignum_mod_multiply(const BasicBignum<Capacity> &left,
+                                const BasicBignum<Capacity> &right,
+                                const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBignum<Capacity> {
   auto result{bignum_multiply(left, right)};
   bignum_reduce(result, modulus);
   return result;
@@ -454,8 +509,10 @@ inline auto bignum_mod_multiply(const Bignum &left, const Bignum &right,
 
 // Halve a value modulo an odd modulus: an even value shifts down, an odd one
 // becomes even by adding the modulus first, so the result stays an integer
-inline auto bignum_mod_halve(const Bignum &value,
-                             const Bignum &modulus) noexcept -> Bignum {
+template <std::size_t Capacity>
+inline auto bignum_mod_halve(const BasicBignum<Capacity> &value,
+                             const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBignum<Capacity> {
   if ((value.words[0] & 1U) == 0) {
     return bignum_shift_right(value, 1);
   }
@@ -468,14 +525,16 @@ inline auto bignum_mod_halve(const Bignum &value,
 // a Fermat inverse over a prime modulus would spend. The modulus must be odd.
 // Returns zero when the value has no inverse, which is when it shares a factor
 // with the modulus or reduces to zero
-inline auto bignum_mod_inverse(const Bignum &value,
-                               const Bignum &modulus) noexcept -> Bignum {
-  const auto one{bignum_from_u64(1)};
+template <std::size_t Capacity>
+inline auto bignum_mod_inverse(const BasicBignum<Capacity> &value,
+                               const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBignum<Capacity> {
+  const auto one{bignum_from_u64<Capacity>(1)};
   auto first{value};
   bignum_reduce(first, modulus);
   auto second{modulus};
   auto first_coefficient{one};
-  Bignum second_coefficient;
+  BasicBignum<Capacity> second_coefficient;
 
   while (bignum_compare(first, one) != 0 && bignum_compare(second, one) != 0) {
     // A side reaching zero means the greatest common divisor exceeds one, so no
@@ -510,18 +569,24 @@ inline auto bignum_mod_inverse(const Bignum &value,
                                          : second_coefficient;
 }
 
-// A branch-free select, so a secret condition does not steer control flow. The
-// whole capacity is blended so the running size does not leak the condition
+// A branch-free select, so a secret condition does not steer control flow. It
+// blends the given number of words, a count fixed by the public operand width,
+// so neither the condition nor the running size steers the loop
+template <std::size_t Capacity>
 inline auto bignum_conditional_select(const bool condition,
-                                      const Bignum &when_true,
-                                      const Bignum &when_false) noexcept
-    -> Bignum {
+                                      const BasicBignum<Capacity> &when_true,
+                                      const BasicBignum<Capacity> &when_false,
+                                      const std::size_t words) noexcept
+    -> BasicBignum<Capacity> {
   const std::uint64_t mask{std::uint64_t{0} -
                            static_cast<std::uint64_t>(condition)};
-  Bignum result;
-  for (std::size_t index = 0; index < Bignum::CAPACITY; ++index) {
-    result.words[index] =
-        (when_true.words[index] & mask) | (when_false.words[index] & ~mask);
+  BasicBignum<Capacity> result;
+  const auto *true_data{when_true.words.data()};
+  const auto *false_data{when_false.words.data()};
+  auto *result_data{result.words.data()};
+  for (std::size_t index = 0; index < words; ++index) {
+    result_data[index] =
+        (true_data[index] & mask) | (false_data[index] & ~mask);
   }
 
   const std::size_t size_mask{std::size_t{0} -
@@ -534,70 +599,197 @@ inline auto bignum_conditional_select(const bool condition,
 // borrow. It always visits every word, so its timing does not depend on where
 // the operands' significant words fall the way the size-driven routines above
 // do
-inline auto bignum_subtract_fixed(const Bignum &left, const Bignum &right,
-                                  const std::size_t words, Bignum &out) noexcept
+template <std::size_t Capacity>
+inline auto bignum_subtract_fixed(const BasicBignum<Capacity> &left,
+                                  const BasicBignum<Capacity> &right,
+                                  const std::size_t words,
+                                  BasicBignum<Capacity> &out) noexcept
     -> std::uint64_t {
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
+  auto *out_data{out.words.data()};
   std::uint64_t borrow{0};
   for (std::size_t index = 0; index < words; ++index) {
-    const auto left_word{left.words[index]};
-    const auto right_word{right.words[index]};
-    const auto without_right{left_word - right_word};
-    const std::uint64_t borrow_from_right{left_word < right_word ? 1U : 0U};
-    const auto result_word{without_right - borrow};
-    const std::uint64_t borrow_from_previous{without_right < borrow ? 1U : 0U};
-    out.words[index] = result_word;
-    borrow = borrow_from_right | borrow_from_previous;
+    // A borrow out of the word wraps the double word, setting its high half
+    const auto total{static_cast<BignumDoubleWord>(left_data[index]) -
+                     right_data[index] - borrow};
+    out_data[index] = static_cast<std::uint64_t>(total);
+    borrow = static_cast<std::uint64_t>(total >> 64U) & 1U;
   }
 
   out.size = words;
   return borrow;
 }
 
+// Add the modulus, masked to all ones or to zero, over the given number of
+// words, discarding the carry out. It is the branch-free correction step of
+// the constant-time modular arithmetic, undoing a trial subtraction of the
+// modulus that borrowed
+template <std::size_t Capacity>
+inline auto bignum_add_masked(BasicBignum<Capacity> &value,
+                              const BasicBignum<Capacity> &modulus,
+                              const std::uint64_t mask,
+                              const std::size_t words) noexcept -> void {
+  auto *value_data{value.words.data()};
+  const auto *modulus_data{modulus.words.data()};
+  std::uint64_t carry{0};
+  for (std::size_t index = 0; index < words; ++index) {
+    const auto total{static_cast<BignumDoubleWord>(value_data[index]) +
+                     (modulus_data[index] & mask) + carry};
+    value_data[index] = static_cast<std::uint64_t>(total);
+    carry = static_cast<std::uint64_t>(total >> 64U);
+  }
+}
+
 // Multiply visiting exactly the given word counts, so timing does not reveal
 // where either operand's significant words fall
-inline auto bignum_multiply_fixed(const Bignum &left, const Bignum &right,
+template <std::size_t Capacity>
+inline auto bignum_multiply_fixed(const BasicBignum<Capacity> &left,
+                                  const BasicBignum<Capacity> &right,
                                   const std::size_t left_words,
                                   const std::size_t right_words) noexcept
-    -> Bignum {
-  Bignum result;
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
+  auto *result_data{result.words.data()};
   for (std::size_t left_index = 0; left_index < left_words; ++left_index) {
+    const auto left_word{left_data[left_index]};
     std::uint64_t carry{0};
     for (std::size_t right_index = 0; right_index < right_words;
          ++right_index) {
       const auto destination{left_index + right_index};
       const auto product{
-          (static_cast<BignumDoubleWord>(left.words[left_index]) *
-           right.words[right_index]) +
-          result.words[destination] + carry};
-      result.words[destination] = static_cast<std::uint64_t>(product);
+          (static_cast<BignumDoubleWord>(left_word) * right_data[right_index]) +
+          result_data[destination] + carry};
+      result_data[destination] = static_cast<std::uint64_t>(product);
       carry = static_cast<std::uint64_t>(product >> 64U);
     }
 
-    result.words[left_index + right_words] = carry;
+    result_data[left_index + right_words] = carry;
   }
 
   result.size = left_words + right_words;
   return result;
 }
 
+// The same product truncated to its given number of low words, visiting only
+// the columns below that width, for a reduction that discards the high words
+template <std::size_t Capacity>
+inline auto bignum_multiply_low_fixed(const BasicBignum<Capacity> &left,
+                                      const BasicBignum<Capacity> &right,
+                                      const std::size_t left_words,
+                                      const std::size_t right_words,
+                                      const std::size_t width) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
+  auto *result_data{result.words.data()};
+  const auto rows{std::min(left_words, width)};
+  for (std::size_t left_index = 0; left_index < rows; ++left_index) {
+    std::uint64_t carry{0};
+    const auto columns{std::min(right_words, width - left_index)};
+    for (std::size_t right_index = 0; right_index < columns; ++right_index) {
+      const auto destination{left_index + right_index};
+      const auto product{(static_cast<BignumDoubleWord>(left_data[left_index]) *
+                          right_data[right_index]) +
+                         result_data[destination] + carry};
+      result_data[destination] = static_cast<std::uint64_t>(product);
+      carry = static_cast<std::uint64_t>(product >> 64U);
+    }
+
+    if (left_index + columns < width) {
+      result_data[left_index + columns] = carry;
+    }
+  }
+
+  result.size = width;
+  return result;
+}
+
+// The square of a value over the given number of words, a count fixed by the
+// public width. Each cross product appears twice in a square, so it is computed
+// once and doubled before the diagonal squares are added
+template <std::size_t Capacity>
+inline auto bignum_square_fixed(const BasicBignum<Capacity> &value,
+                                const std::size_t words) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
+  const auto *value_data{value.words.data()};
+  auto *result_data{result.words.data()};
+  for (std::size_t left_index = 0; left_index < words; ++left_index) {
+    const auto left_word{value_data[left_index]};
+    std::uint64_t carry{0};
+    for (std::size_t right_index = left_index + 1; right_index < words;
+         ++right_index) {
+      const auto destination{left_index + right_index};
+      const auto product{
+          (static_cast<BignumDoubleWord>(left_word) * value_data[right_index]) +
+          result_data[destination] + carry};
+      result_data[destination] = static_cast<std::uint64_t>(product);
+      carry = static_cast<std::uint64_t>(product >> 64U);
+    }
+
+    result_data[left_index + words] = carry;
+  }
+
+  std::uint64_t shifted_out{0};
+  for (std::size_t index = 0; index < 2 * words; ++index) {
+    const auto word{result_data[index]};
+    result_data[index] = (word << 1U) | shifted_out;
+    shifted_out = word >> 63U;
+  }
+
+  std::uint64_t carry{0};
+  for (std::size_t index = 0; index < words; ++index) {
+    const auto square{static_cast<BignumDoubleWord>(value_data[index]) *
+                      value_data[index]};
+    const auto low{static_cast<BignumDoubleWord>(result_data[2 * index]) +
+                   static_cast<std::uint64_t>(square) + carry};
+    result_data[2 * index] = static_cast<std::uint64_t>(low);
+    const auto high{
+        static_cast<BignumDoubleWord>(result_data[(2 * index) + 1]) +
+        static_cast<std::uint64_t>(square >> 64U) +
+        static_cast<std::uint64_t>(low >> 64U)};
+    result_data[(2 * index) + 1] = static_cast<std::uint64_t>(high);
+    carry = static_cast<std::uint64_t>(high >> 64U);
+  }
+
+  result.size = 2 * words;
+  return result;
+}
+
 // A word-granular right shift dropping the low words, and its counterpart that
-// keeps them, for the word-aligned truncations the Barrett reduction needs
-inline auto bignum_drop_low_words(const Bignum &value,
-                                  const std::size_t words) noexcept -> Bignum {
-  Bignum result;
-  for (std::size_t index = 0; index + words < Bignum::CAPACITY; ++index) {
-    result.words[index] = value.words[index + words];
+// keeps them, for the word-aligned truncations the Barrett reduction needs. The
+// shift keeps the given number of words above the dropped ones, a count fixed
+// by the public modulus width rather than by the operand size
+template <std::size_t Capacity>
+inline auto bignum_drop_low_words(const BasicBignum<Capacity> &value,
+                                  const std::size_t words,
+                                  const std::size_t width) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
+  const auto *value_data{value.words.data()};
+  auto *result_data{result.words.data()};
+  for (std::size_t index = 0; index < width && index + words < Capacity;
+       ++index) {
+    result_data[index] = value_data[index + words];
   }
 
-  result.size = value.size > words ? value.size - words : 0;
+  result.size = value.size > words ? std::min(value.size - words, width) : 0;
   return result;
 }
 
-inline auto bignum_keep_low_words(const Bignum &value,
-                                  const std::size_t words) noexcept -> Bignum {
-  Bignum result;
+template <std::size_t Capacity>
+inline auto bignum_keep_low_words(const BasicBignum<Capacity> &value,
+                                  const std::size_t words) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> result;
+  const auto *value_data{value.words.data()};
+  auto *result_data{result.words.data()};
   for (std::size_t index = 0; index < words; ++index) {
-    result.words[index] = value.words[index];
+    result_data[index] = value_data[index];
   }
 
   result.size = words;
@@ -606,10 +798,12 @@ inline auto bignum_keep_low_words(const Bignum &value,
 
 // Quotient of a division, for building a public reduction constant only, so a
 // plain bit-by-bit long division is enough
-inline auto bignum_divide(const Bignum &numerator,
-                          const Bignum &denominator) noexcept -> Bignum {
-  Bignum quotient;
-  Bignum remainder;
+template <std::size_t Capacity>
+inline auto bignum_divide(const BasicBignum<Capacity> &numerator,
+                          const BasicBignum<Capacity> &denominator) noexcept
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> quotient;
+  BasicBignum<Capacity> remainder;
   const auto bits{bignum_bit_length(numerator)};
   for (std::size_t index = bits; index > 0; --index) {
     remainder = bignum_shift_left(remainder, 1);
@@ -631,50 +825,110 @@ inline auto bignum_divide(const Bignum &numerator,
   return quotient;
 }
 
-// Precomputed constants for Barrett reduction modulo a fixed modulus. Built
-// from the public modulus alone, so the setup itself need not be constant time
-struct BarrettContext {
-  Bignum modulus;
+// Precomputed constants for Barrett reduction modulo a fixed modulus. The plain
+// setup below reads a public modulus, so it need not be constant time
+template <std::size_t Capacity> struct BasicBarrettContext {
+  using Reduction = auto (*)(const BasicBignum<Capacity> &,
+                             const BasicBarrettContext &) noexcept
+      -> BasicBignum<Capacity>;
+  BasicBignum<Capacity> modulus;
   std::size_t words;
-  Bignum factor;
+  BasicBignum<Capacity> factor;
+  // A constant-time reduction of a product below the square of the modulus that
+  // a special form of the modulus allows, taken instead of the Barrett one when
+  // set
+  Reduction reduce{nullptr};
+  // The constants of a context that reduces through Montgomery multiplication:
+  // the negated inverse of the modulus modulo 2^64, left zero by a context that
+  // does not, and R^2 modulo the modulus for moving values into Montgomery form
+  std::uint64_t montgomery_factor{0};
+  BasicBignum<Capacity> montgomery_square;
 };
 
-inline auto barrett_context(const Bignum &modulus) noexcept -> BarrettContext {
-  BarrettContext context;
+using BarrettContext = BasicBarrettContext<BIGNUM_CAPACITY>;
+using CurveBarrettContext = BasicBarrettContext<CURVE_BIGNUM_CAPACITY>;
+
+template <std::size_t Capacity>
+inline auto barrett_context(const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBarrettContext<Capacity> {
+  BasicBarrettContext<Capacity> context;
   context.modulus = modulus;
   context.words = modulus.size;
-  const auto power{bignum_shift_left(bignum_from_u64(1), 128 * context.words)};
+  const auto power{
+      bignum_shift_left(bignum_from_u64<Capacity>(1), 128 * context.words)};
   context.factor = bignum_divide(power, modulus);
   return context;
 }
 
+// The same constants for a secret modulus, such as a prime factor of an RSA
+// key, built in constant time. The quotient comes from binary long division
+// over the public bit length of the power, where a fixed-width subtraction and
+// a masked select stand in for each comparison
+template <std::size_t Capacity>
+inline auto barrett_context_ct(const BasicBignum<Capacity> &modulus) noexcept
+    -> BasicBarrettContext<Capacity> {
+  BasicBarrettContext<Capacity> context;
+  context.modulus = modulus;
+  context.words = modulus.size;
+  const auto width{context.words + 1};
+  const auto power_bits{(128 * context.words) + 1};
+  BasicBignum<Capacity> remainder;
+  remainder.size = width;
+  BasicBignum<Capacity> quotient;
+  for (std::size_t index = power_bits; index > 0; --index) {
+    // The power is a single set bit above zeros, so only its top bit carries in
+    std::uint64_t carry{index == power_bits ? 1U : 0U};
+    auto *remainder_data{remainder.words.data()};
+    for (std::size_t word = 0; word < width; ++word) {
+      const auto current{remainder_data[word]};
+      remainder_data[word] = (current << 1U) | carry;
+      carry = current >> 63U;
+    }
+
+    BasicBignum<Capacity> trial;
+    const auto borrow{bignum_subtract_fixed(remainder, modulus, width, trial)};
+    remainder = bignum_conditional_select(borrow == 0, trial, remainder, width);
+    quotient.words[(index - 1) / 64] |= static_cast<std::uint64_t>(borrow == 0)
+                                        << ((index - 1) % 64);
+  }
+
+  secure_zero(remainder);
+  quotient.size = width;
+  context.factor = quotient;
+  secure_zero(quotient);
+  return context;
+}
+
 // If the value is at least the modulus over the given width, subtract it. The
 // choice is a masked select rather than a branch
-inline auto bignum_conditional_subtract(const Bignum &value,
-                                        const Bignum &modulus,
+template <std::size_t Capacity>
+inline auto bignum_conditional_subtract(const BasicBignum<Capacity> &value,
+                                        const BasicBignum<Capacity> &modulus,
                                         const std::size_t words) noexcept
-    -> Bignum {
-  Bignum reduced;
+    -> BasicBignum<Capacity> {
+  BasicBignum<Capacity> reduced;
   const auto borrow{bignum_subtract_fixed(value, modulus, words, reduced)};
-  return bignum_conditional_select(borrow == 0, reduced, value);
+  return bignum_conditional_select(borrow == 0, reduced, value, words);
 }
 
 // Reduce a value below the square of the modulus down to the modulus in
 // constant time (Handbook of Applied Cryptography Algorithm 14.42). The
 // estimate is at most two too small, so three masked subtractions always finish
 // the reduction
-inline auto barrett_reduce(const Bignum &value,
-                           const BarrettContext &context) noexcept -> Bignum {
+template <std::size_t Capacity>
+inline auto
+barrett_reduce(const BasicBignum<Capacity> &value,
+               const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
   const auto width{context.words};
-  const auto high{bignum_drop_low_words(value, width - 1)};
+  const auto high{bignum_drop_low_words(value, width - 1, width + 1)};
   const auto estimate{
       bignum_multiply_fixed(high, context.factor, width + 1, width + 1)};
-  const auto quotient{bignum_drop_low_words(estimate, width + 1)};
+  const auto quotient{bignum_drop_low_words(estimate, width + 1, width + 1)};
   const auto value_low{bignum_keep_low_words(value, width + 1)};
-  const auto product{
-      bignum_multiply_fixed(quotient, context.modulus, width + 1, width)};
-  const auto product_low{bignum_keep_low_words(product, width + 1)};
-  Bignum remainder;
+  const auto product_low{bignum_multiply_low_fixed(
+      quotient, context.modulus, width + 1, width, width + 1)};
+  BasicBignum<Capacity> remainder;
   bignum_subtract_fixed(value_low, product_low, width + 1, remainder);
   remainder =
       bignum_conditional_subtract(remainder, context.modulus, width + 1);
@@ -686,102 +940,317 @@ inline auto barrett_reduce(const Bignum &value,
   return remainder;
 }
 
-inline auto field_mod_multiply_ct(const Bignum &left, const Bignum &right,
-                                  const BarrettContext &context) noexcept
-    -> Bignum {
-  return barrett_reduce(
-      bignum_multiply_fixed(left, right, context.words, context.words),
-      context);
+// Montgomery reduction in constant time, the separated operand scanning form
+// (Koc, Acar, and Kaliski 1996). It divides a value below the modulus times
+// R = 2^(64 * words) by R modulo the modulus, clearing one low word per step
+// with a multiple of the modulus chosen from that word alone, so every step
+// visits the same words whatever the operands hold, and the quotient, below
+// twice the modulus, needs a single subtraction of the modulus, undone through
+// a masked addition when it borrows past the overflow word
+template <std::size_t Capacity>
+inline auto
+montgomery_reduce_ct(const BasicBignum<Capacity> &value,
+                     const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  const auto width{context.words};
+  auto accumulator{value};
+  auto *accumulator_data{accumulator.words.data()};
+  const auto *modulus_data{context.modulus.words.data()};
+  std::uint64_t overflow{0};
+  for (std::size_t index = 0; index < width; ++index) {
+    const std::uint64_t multiplier{accumulator_data[index] *
+                                   context.montgomery_factor};
+    std::uint64_t carry{0};
+    for (std::size_t word = 0; word < width; ++word) {
+      const auto total{
+          (static_cast<BignumDoubleWord>(multiplier) * modulus_data[word]) +
+          accumulator_data[index + word] + carry};
+      accumulator_data[index + word] = static_cast<std::uint64_t>(total);
+      carry = static_cast<std::uint64_t>(total >> 64U);
+    }
+
+    const auto total{
+        static_cast<BignumDoubleWord>(accumulator_data[index + width]) + carry +
+        overflow};
+    accumulator_data[index + width] = static_cast<std::uint64_t>(total);
+    overflow = static_cast<std::uint64_t>(total >> 64U);
+  }
+
+  BasicBignum<Capacity> result;
+  auto *result_data{result.words.data()};
+  std::uint64_t borrow{0};
+  for (std::size_t index = 0; index < width; ++index) {
+    const auto total{
+        static_cast<BignumDoubleWord>(accumulator_data[index + width]) -
+        modulus_data[index] - borrow};
+    result_data[index] = static_cast<std::uint64_t>(total);
+    borrow = static_cast<std::uint64_t>(total >> 64U) & 1U;
+  }
+
+  bignum_add_masked(
+      result, context.modulus,
+      std::uint64_t{0} - static_cast<std::uint64_t>(borrow > overflow), width);
+  result.size = width;
+  return result;
 }
 
-inline auto field_add_ct(const Bignum &left, const Bignum &right,
-                         const BarrettContext &context) noexcept -> Bignum {
+// A context reducing through Montgomery multiplication, built from a Barrett
+// one. The negated inverse of the modulus modulo 2^64 comes from Newton
+// iteration, which doubles the correct low bits at every step from the three
+// that an odd word already has, and R^2 modulo the modulus comes from the
+// Barrett quotient as 2^(128 * words) minus the quotient times the modulus.
+// Both run in constant time, as the modulus may be a secret prime factor. The
+// modulus must be odd
+template <std::size_t Capacity>
+inline auto
+montgomery_context(const BasicBarrettContext<Capacity> &barrett) noexcept
+    -> BasicBarrettContext<Capacity> {
+  auto context{barrett};
   const auto width{context.words};
-  Bignum sum;
-  std::uint64_t carry{0};
-  for (std::size_t index = 0; index < width; ++index) {
-    const auto total{static_cast<BignumDoubleWord>(left.words[index]) +
-                     right.words[index] + carry};
-    sum.words[index] = static_cast<std::uint64_t>(total);
-    carry = static_cast<std::uint64_t>(total >> 64U);
+  const auto lowest{context.modulus.words[0]};
+  std::uint64_t inverse{lowest};
+  for (std::size_t step = 0; step < 5; ++step) {
+    inverse *= 2U - (lowest * inverse);
+  }
+
+  context.montgomery_factor = std::uint64_t{0} - inverse;
+  const auto product{bignum_multiply_low_fixed(context.factor, context.modulus,
+                                               width + 1, width, 2 * width)};
+  const BasicBignum<Capacity> zero;
+  bignum_subtract_fixed(zero, product, 2 * width, context.montgomery_square);
+  context.montgomery_square.size = width;
+  context.reduce = &montgomery_reduce_ct<Capacity>;
+  return context;
+}
+
+template <std::size_t Capacity>
+inline auto
+field_mod_multiply_ct(const BasicBignum<Capacity> &left,
+                      const BasicBignum<Capacity> &right,
+                      const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  const auto product{
+      bignum_multiply_fixed(left, right, context.words, context.words)};
+  return context.reduce == nullptr ? barrett_reduce(product, context)
+                                   : context.reduce(product, context);
+}
+
+template <std::size_t Capacity>
+inline auto
+field_square_ct(const BasicBignum<Capacity> &value,
+                const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  const auto square{bignum_square_fixed(value, context.words)};
+  return context.reduce == nullptr ? barrett_reduce(square, context)
+                                   : context.reduce(square, context);
+}
+
+// Move a reduced value into the representation of a context, its Montgomery
+// form x * R modulo the modulus when the context reduces through Montgomery
+// multiplication, and the value itself otherwise
+template <std::size_t Capacity>
+inline auto
+field_to_montgomery_ct(const BasicBignum<Capacity> &value,
+                       const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  if (context.montgomery_factor == 0) {
+    return value;
   }
 
-  sum.words[width] = carry;
-  sum.size = width + 1;
-  auto reduced{bignum_conditional_subtract(sum, context.modulus, width + 1)};
-  reduced.size = width;
-  return reduced;
+  return field_mod_multiply_ct(value, context.montgomery_square, context);
 }
 
-inline auto field_subtract_ct(const Bignum &left, const Bignum &right,
-                              const BarrettContext &context) noexcept
-    -> Bignum {
+// Move a value back out of the representation of a context
+template <std::size_t Capacity>
+inline auto
+field_from_montgomery_ct(const BasicBignum<Capacity> &value,
+                         const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  if (context.montgomery_factor == 0) {
+    return value;
+  }
+
+  return montgomery_reduce_ct(value, context);
+}
+
+template <std::size_t Capacity>
+inline auto field_add_ct(const BasicBignum<Capacity> &left,
+                         const BasicBignum<Capacity> &right,
+                         const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
   const auto width{context.words};
-  Bignum difference;
-  const auto borrow{bignum_subtract_fixed(left, right, width, difference)};
-  Bignum wrapped;
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
+  const auto *modulus_data{context.modulus.words.data()};
+  BasicBignum<Capacity> result;
+  auto *result_data{result.words.data()};
+  // The modulus comes off the sum as the sum forms, and goes back on when that
+  // subtraction borrowed past the carry out of the sum
   std::uint64_t carry{0};
+  std::uint64_t borrow{0};
   for (std::size_t index = 0; index < width; ++index) {
-    const auto total{static_cast<BignumDoubleWord>(difference.words[index]) +
-                     context.modulus.words[index] + carry};
-    wrapped.words[index] = static_cast<std::uint64_t>(total);
+    const auto total{static_cast<BignumDoubleWord>(left_data[index]) +
+                     right_data[index] + carry};
     carry = static_cast<std::uint64_t>(total >> 64U);
+    const auto difference{
+        static_cast<BignumDoubleWord>(static_cast<std::uint64_t>(total)) -
+        modulus_data[index] - borrow};
+    result_data[index] = static_cast<std::uint64_t>(difference);
+    borrow = static_cast<std::uint64_t>(difference >> 64U) & 1U;
   }
 
-  wrapped.size = width;
-  auto result{bignum_conditional_select(borrow != 0, wrapped, difference)};
+  bignum_add_masked(
+      result, context.modulus,
+      std::uint64_t{0} - static_cast<std::uint64_t>(borrow > carry), width);
   result.size = width;
   return result;
 }
 
+template <std::size_t Capacity>
+inline auto
+field_subtract_ct(const BasicBignum<Capacity> &left,
+                  const BasicBignum<Capacity> &right,
+                  const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  const auto width{context.words};
+  BasicBignum<Capacity> difference;
+  const auto borrow{bignum_subtract_fixed(left, right, width, difference)};
+  bignum_add_masked(difference, context.modulus, std::uint64_t{0} - borrow,
+                    width);
+  return difference;
+}
+
+// Whether two field elements, both reduced below the modulus, are equal,
+// comparing every word of the public width without an early exit
+template <std::size_t Capacity>
+inline auto
+field_equal_ct(const BasicBignum<Capacity> &left,
+               const BasicBignum<Capacity> &right,
+               const BasicBarrettContext<Capacity> &context) noexcept -> bool {
+  const auto *left_data{left.words.data()};
+  const auto *right_data{right.words.data()};
+  std::uint64_t difference{0};
+  for (std::size_t index = 0; index < context.words; ++index) {
+    difference |= left_data[index] ^ right_data[index];
+  }
+
+  return difference == 0;
+}
+
+// Raise a value to a public exponent over the field in fixed four-bit windows.
+// The exponent is public, so its windows index the table of powers directly and
+// skip the multiplication of a zero window, while the field multiplications
+// underneath do not depend on the value being raised. A context without a
+// special reduction runs the powering in Montgomery form, whose reduction is
+// cheaper than the Barrett one, so its modulus must be odd
+template <std::size_t Capacity>
+inline auto
+field_power_ct(const BasicBignum<Capacity> &value,
+               const BasicBignum<Capacity> &exponent,
+               const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  const auto field{context.reduce == nullptr ? montgomery_context(context)
+                                             : context};
+  std::array<BasicBignum<Capacity>, 16> powers{};
+  powers[0] = field_to_montgomery_ct(bignum_from_u64<Capacity>(1), field);
+  powers[0].size = context.words;
+  powers[1] = field_to_montgomery_ct(barrett_reduce(value, context), field);
+  for (std::size_t index = 2; index < powers.size(); ++index) {
+    powers[index] = field_mod_multiply_ct(powers[index - 1], powers[1], field);
+  }
+
+  auto result{powers[0]};
+  const auto windows{(bignum_bit_length(exponent) + 3) / 4};
+  for (std::size_t window = windows; window > 0; --window) {
+    for (std::size_t step = 0; step < 4; ++step) {
+      result = field_square_ct(result, field);
+    }
+
+    std::size_t digit{0};
+    for (std::size_t bit = 0; bit < 4; ++bit) {
+      digit |= static_cast<std::size_t>(
+                   bignum_get_bit(exponent, ((window - 1) * 4) + bit))
+               << bit;
+    }
+
+    if (digit != 0) {
+      result = field_mod_multiply_ct(result, powers[digit], field);
+    }
+  }
+
+  return field_from_montgomery_ct(result, field);
+}
+
 // Fermat inverse over the field in constant time. The exponent is the public
 // modulus minus two, so its bit pattern reveals nothing secret, and the field
 // multiplications underneath do not depend on the value being inverted. The
 // modulus must be prime
-inline auto field_inverse_ct(const Bignum &value,
-                             const BarrettContext &context) noexcept -> Bignum {
+template <std::size_t Capacity>
+inline auto
+field_inverse_ct(const BasicBignum<Capacity> &value,
+                 const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
   auto exponent{context.modulus};
-  bignum_subtract_in_place(exponent, bignum_from_u64(2));
-  Bignum result;
-  result.words[0] = 1;
-  result.size = context.words;
-  const auto base{barrett_reduce(value, context)};
-  const auto exponent_bits{bignum_bit_length(exponent)};
-  for (std::size_t index = exponent_bits; index > 0; --index) {
-    result = field_mod_multiply_ct(result, result, context);
-    if (bignum_get_bit(exponent, index - 1)) {
-      result = field_mod_multiply_ct(result, base, context);
-    }
-  }
-
-  return result;
+  bignum_subtract_in_place(exponent, bignum_from_u64<Capacity>(2));
+  return field_power_ct(value, exponent, context);
 }
 
 // Modular exponentiation for a secret exponent (the RSA private key), in
-// constant time. Unlike the inverse above, the exponent is secret, so the
-// ladder runs a fixed number of steps fixed by the public modulus and blends
-// the per-bit multiply with a masked select rather than a branch. The modulus
-// need not be prime
-inline auto bignum_mod_exp_ct(const Bignum &base, const Bignum &exponent,
-                              const BarrettContext &context) noexcept
-    -> Bignum {
-  Bignum result;
-  result.words[0] = 1;
-  result.size = context.words;
-  const auto reduced_base{barrett_reduce(base, context)};
-  const auto exponent_bits{bignum_bit_length(context.modulus)};
-  for (std::size_t index = exponent_bits; index > 0; --index) {
-    result = field_mod_multiply_ct(result, result, context);
-    const auto product{field_mod_multiply_ct(result, reduced_base, context)};
-    result = bignum_conditional_select(
-        bignum_get_bit_fixed(exponent, index - 1), product, result);
+// constant time. The exponent is secret, so it is consumed in fixed four-bit
+// windows over a count fixed by the public modulus, and every window multiplies
+// by a power of the base taken from a precomputed table through a masked scan
+// over all of its entries rather than an index. The exponentiation runs in
+// Montgomery form, whose reduction is cheaper than the Barrett one, and the
+// Montgomery constants are wiped on return, as the modulus may be a secret
+// prime factor. The modulus need not be prime, but must be odd
+template <std::size_t Capacity>
+inline auto
+bignum_mod_exp_ct(const BasicBignum<Capacity> &base,
+                  const BasicBignum<Capacity> &exponent,
+                  const BasicBarrettContext<Capacity> &context) noexcept
+    -> BasicBignum<Capacity> {
+  auto montgomery{montgomery_context(context)};
+  const SecureBignumScope montgomery_modulus_scope{montgomery.modulus};
+  const SecureBignumScope montgomery_factor_scope{montgomery.factor};
+  const SecureBignumScope montgomery_square_scope{montgomery.montgomery_square};
+  const auto width{context.words};
+  std::array<BasicBignum<Capacity>, 16> powers{};
+  powers[0] = field_to_montgomery_ct(bignum_from_u64<Capacity>(1), montgomery);
+  powers[1] = field_to_montgomery_ct(barrett_reduce(base, context), montgomery);
+  for (std::size_t index = 2; index < powers.size(); ++index) {
+    powers[index] =
+        field_mod_multiply_ct(powers[index - 1], powers[1], montgomery);
   }
 
-  return result;
+  const auto windows{(bignum_bit_length(context.modulus) + 3) / 4};
+  auto result{powers[0]};
+  for (std::size_t window = windows; window > 0; --window) {
+    for (std::size_t step = 0; step < 4; ++step) {
+      result = field_square_ct(result, montgomery);
+    }
+
+    std::size_t digit{0};
+    for (std::size_t bit = 0; bit < 4; ++bit) {
+      digit |= static_cast<std::size_t>(
+                   bignum_get_bit_fixed(exponent, ((window - 1) * 4) + bit))
+               << bit;
+    }
+
+    BasicBignum<Capacity> selected;
+    for (std::size_t index = 0; index < powers.size(); ++index) {
+      selected = bignum_conditional_select(digit == index, powers[index],
+                                           selected, width);
+    }
+
+    result = field_mod_multiply_ct(result, selected, montgomery);
+  }
+
+  return field_from_montgomery_ct(result, montgomery);
 }
 
-inline auto bignum_to_bytes(const Bignum &value, const std::size_t length)
-    -> std::string {
+template <std::size_t Capacity>
+inline auto bignum_to_bytes(const BasicBignum<Capacity> &value,
+                            const std::size_t length) -> std::string {
   std::string result(length, '\x00');
   for (std::size_t index = 0; index < length; ++index) {
     const auto word_index{index / 8};
diff --git a/vendor/core/src/core/crypto/crypto_crc32.cc b/vendor/core/src/core/crypto/crypto_crc32.cc
index 80a32840..4bc397c2 100644
--- a/vendor/core/src/core/crypto/crypto_crc32.cc
+++ b/vendor/core/src/core/crypto/crypto_crc32.cc
@@ -2,7 +2,7 @@
 
 #include <array>   // std::array
 #include <cstddef> // std::size_t
-#include <cstdint> // std::uint8_t, std::uint32_t, std::uint64_t, std::uintptr_t
+#include <cstdint> // std::uint8_t, std::uint32_t, std::uint64_t
 #include <cstring> // std::memcpy
 
 // Only enable the hardware CRC32 path when the target ISA explicitly promises
@@ -12,6 +12,31 @@
 // effect
 #if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32)
 #define SOURCEMETA_CORE_CRYPTO_CRC32_ARM 1
+// Carry-less multiplication is part of the cryptographic extension
+#if defined(__ARM_FEATURE_CRYPTO) || defined(__ARM_FEATURE_AES)
+#define SOURCEMETA_CORE_CRYPTO_CRC32_PMULL 1
+#endif
+#endif
+
+// Every x86 processor with AVX2 also has carry-less multiplication, which
+// MSVC exposes without a dedicated flag
+#if (defined(__x86_64__) || defined(_M_X64)) &&                                \
+    (defined(__PCLMUL__) ||                                                    \
+     (defined(_MSC_VER) && !defined(__clang__) && defined(__AVX2__)))
+#define SOURCEMETA_CORE_CRYPTO_CRC32_CLMUL 1
+#endif
+
+#if defined(SOURCEMETA_CORE_CRYPTO_CRC32_PMULL) ||                             \
+    defined(SOURCEMETA_CORE_CRYPTO_CRC32_CLMUL)
+#define SOURCEMETA_CORE_CRYPTO_CRC32_FOLD 1
+#endif
+
+#ifdef SOURCEMETA_CORE_CRYPTO_CRC32_PMULL
+#include <arm_neon.h> // uint8x16_t, poly64x2_t, vmull_p64, vmull_high_p64
+#endif
+
+#ifdef SOURCEMETA_CORE_CRYPTO_CRC32_CLMUL
+#include <immintrin.h> // __m128i, _mm_clmulepi64_si128, _mm_xor_si128
 #endif
 
 // The CRC32 operations are reached through compiler builtins rather than the
@@ -40,73 +65,503 @@ auto crc32_hardware_byte(const std::uint32_t checksum,
 #endif
 }
 
-} // namespace
-#endif
+#ifndef SOURCEMETA_CORE_CRYPTO_CRC32_PMULL
+// Chunks are checksummed as independent dependency chains that the processor
+// can run in parallel, and the checksums are combined afterwards
+constexpr std::size_t CRC32_CHUNK_SIZE{1024};
 
-#ifndef SOURCEMETA_CORE_CRYPTO_CRC32_ARM
-namespace {
+constexpr auto crc32_byte_table() -> std::array<std::uint32_t, 256> {
+  std::array<std::uint32_t, 256> table{};
+  for (std::uint32_t byte = 0; byte < 256; ++byte) {
+    std::uint32_t value{byte};
+    for (unsigned int bit = 0; bit < 8; ++bit) {
+      value = (value & 1U) != 0 ? (value >> 1U) ^ 0xEDB88320U : value >> 1U;
+    }
 
-constexpr auto compute_crc32_table_entry(const std::uint32_t value) noexcept
-    -> std::uint32_t {
-  auto entry{value};
-  for (int bit_index = 0; bit_index < 8; ++bit_index) {
-    const auto mask{
-        static_cast<std::uint32_t>(-static_cast<std::int32_t>(entry & 1u))};
-    entry = (entry >> 1u) ^ (0xEDB88320u & mask);
+    table[byte] = value;
   }
-  return entry;
+
+  return table;
 }
 
-constexpr auto build_crc32_tables() noexcept
-    -> std::array<std::array<std::uint32_t, 256>, 8> {
-  std::array<std::array<std::uint32_t, 256>, 8> tables{};
-  for (std::uint32_t index = 0; index < 256u; ++index) {
-    tables[0][index] = compute_crc32_table_entry(index);
+// Advancing the checksum register over a run of zero bytes is linear in the
+// register, so it decomposes into one lookup per register byte
+constexpr auto crc32_shift_tables(const std::size_t zero_bytes)
+    -> std::array<std::array<std::uint32_t, 256>, 4> {
+  const auto table{crc32_byte_table()};
+  std::array<std::uint32_t, 32> basis{};
+  for (unsigned int bit = 0; bit < 32; ++bit) {
+    std::uint32_t value{1U << bit};
+    for (std::size_t index = 0; index < zero_bytes; ++index) {
+      value = table[value & 0xffU] ^ (value >> 8U);
+    }
+
+    basis[bit] = value;
   }
-  // Slice-by-8 extension: T[k][b] = (T[k-1][b] >> 8) ^ T[0][T[k-1][b] & 0xff]
-  for (std::size_t slice = 1; slice < 8; ++slice) {
-    for (std::uint32_t index = 0; index < 256u; ++index) {
-      const auto previous{tables[slice - 1][index]};
-      tables[slice][index] = (previous >> 8u) ^ tables[0][previous & 0xffu];
+
+  std::array<std::array<std::uint32_t, 256>, 4> result{};
+  for (std::size_t position = 0; position < 4; ++position) {
+    for (std::uint32_t byte = 0; byte < 256; ++byte) {
+      std::uint32_t value{0};
+      for (unsigned int bit = 0; bit < 8; ++bit) {
+        if (((byte >> bit) & 1U) != 0) {
+          value ^= basis[(position * 8) + bit];
+        }
+      }
+
+      result[position][byte] = value;
     }
   }
-  return tables;
+
+  return result;
 }
 
-constexpr std::array<std::array<std::uint32_t, 256>, 8> CRC32_TABLES{
-    build_crc32_tables()};
+constexpr auto CRC32_CHUNK_SHIFT{crc32_shift_tables(CRC32_CHUNK_SIZE)};
 
-} // namespace
+auto crc32_shift_chunk(const std::uint32_t checksum) noexcept -> std::uint32_t {
+  return CRC32_CHUNK_SHIFT[0][checksum & 0xffU] ^
+         CRC32_CHUNK_SHIFT[1][(checksum >> 8U) & 0xffU] ^
+         CRC32_CHUNK_SHIFT[2][(checksum >> 16U) & 0xffU] ^
+         CRC32_CHUNK_SHIFT[3][checksum >> 24U];
+}
+
+auto crc32_hardware_load(const std::uint8_t *data) noexcept -> std::uint64_t {
+  std::uint64_t chunk{0};
+  std::memcpy(&chunk, data, sizeof(chunk));
+  return chunk;
+}
 #endif
 
-namespace sourcemeta::core {
+} // namespace
+#endif
 
-auto crc32(const std::string_view input) -> std::uint32_t {
-  return crc32_update(0U, input);
-}
+#ifndef SOURCEMETA_CORE_CRYPTO_CRC32_ARM
+namespace {
 
-auto crc32_update(const std::uint32_t previous, const std::string_view input)
-    -> std::uint32_t {
-  auto checksum{previous ^ 0xFFFFFFFFU};
-  const auto *data{reinterpret_cast<const std::uint8_t *>(input.data())};
-  auto remaining{input.size()};
+// The slice-by-8 tables for the reflected CRC-32 polynomial 0xEDB88320, where
+// the first is the classic byte-at-a-time table and every other one follows
+// as T[k][b] = (T[k-1][b] >> 8) ^ T[0][T[k-1][b] & 0xff]
+constexpr std::array<std::array<std::uint32_t, 256>, 8> CRC32_TABLES{
+    {{{0x00000000u, 0x77073096u, 0xEE0E612Cu, 0x990951BAu, 0x076DC419u,
+       0x706AF48Fu, 0xE963A535u, 0x9E6495A3u, 0x0EDB8832u, 0x79DCB8A4u,
+       0xE0D5E91Eu, 0x97D2D988u, 0x09B64C2Bu, 0x7EB17CBDu, 0xE7B82D07u,
+       0x90BF1D91u, 0x1DB71064u, 0x6AB020F2u, 0xF3B97148u, 0x84BE41DEu,
+       0x1ADAD47Du, 0x6DDDE4EBu, 0xF4D4B551u, 0x83D385C7u, 0x136C9856u,
+       0x646BA8C0u, 0xFD62F97Au, 0x8A65C9ECu, 0x14015C4Fu, 0x63066CD9u,
+       0xFA0F3D63u, 0x8D080DF5u, 0x3B6E20C8u, 0x4C69105Eu, 0xD56041E4u,
+       0xA2677172u, 0x3C03E4D1u, 0x4B04D447u, 0xD20D85FDu, 0xA50AB56Bu,
+       0x35B5A8FAu, 0x42B2986Cu, 0xDBBBC9D6u, 0xACBCF940u, 0x32D86CE3u,
+       0x45DF5C75u, 0xDCD60DCFu, 0xABD13D59u, 0x26D930ACu, 0x51DE003Au,
+       0xC8D75180u, 0xBFD06116u, 0x21B4F4B5u, 0x56B3C423u, 0xCFBA9599u,
+       0xB8BDA50Fu, 0x2802B89Eu, 0x5F058808u, 0xC60CD9B2u, 0xB10BE924u,
+       0x2F6F7C87u, 0x58684C11u, 0xC1611DABu, 0xB6662D3Du, 0x76DC4190u,
+       0x01DB7106u, 0x98D220BCu, 0xEFD5102Au, 0x71B18589u, 0x06B6B51Fu,
+       0x9FBFE4A5u, 0xE8B8D433u, 0x7807C9A2u, 0x0F00F934u, 0x9609A88Eu,
+       0xE10E9818u, 0x7F6A0DBBu, 0x086D3D2Du, 0x91646C97u, 0xE6635C01u,
+       0x6B6B51F4u, 0x1C6C6162u, 0x856530D8u, 0xF262004Eu, 0x6C0695EDu,
+       0x1B01A57Bu, 0x8208F4C1u, 0xF50FC457u, 0x65B0D9C6u, 0x12B7E950u,
+       0x8BBEB8EAu, 0xFCB9887Cu, 0x62DD1DDFu, 0x15DA2D49u, 0x8CD37CF3u,
+       0xFBD44C65u, 0x4DB26158u, 0x3AB551CEu, 0xA3BC0074u, 0xD4BB30E2u,
+       0x4ADFA541u, 0x3DD895D7u, 0xA4D1C46Du, 0xD3D6F4FBu, 0x4369E96Au,
+       0x346ED9FCu, 0xAD678846u, 0xDA60B8D0u, 0x44042D73u, 0x33031DE5u,
+       0xAA0A4C5Fu, 0xDD0D7CC9u, 0x5005713Cu, 0x270241AAu, 0xBE0B1010u,
+       0xC90C2086u, 0x5768B525u, 0x206F85B3u, 0xB966D409u, 0xCE61E49Fu,
+       0x5EDEF90Eu, 0x29D9C998u, 0xB0D09822u, 0xC7D7A8B4u, 0x59B33D17u,
+       0x2EB40D81u, 0xB7BD5C3Bu, 0xC0BA6CADu, 0xEDB88320u, 0x9ABFB3B6u,
+       0x03B6E20Cu, 0x74B1D29Au, 0xEAD54739u, 0x9DD277AFu, 0x04DB2615u,
+       0x73DC1683u, 0xE3630B12u, 0x94643B84u, 0x0D6D6A3Eu, 0x7A6A5AA8u,
+       0xE40ECF0Bu, 0x9309FF9Du, 0x0A00AE27u, 0x7D079EB1u, 0xF00F9344u,
+       0x8708A3D2u, 0x1E01F268u, 0x6906C2FEu, 0xF762575Du, 0x806567CBu,
+       0x196C3671u, 0x6E6B06E7u, 0xFED41B76u, 0x89D32BE0u, 0x10DA7A5Au,
+       0x67DD4ACCu, 0xF9B9DF6Fu, 0x8EBEEFF9u, 0x17B7BE43u, 0x60B08ED5u,
+       0xD6D6A3E8u, 0xA1D1937Eu, 0x38D8C2C4u, 0x4FDFF252u, 0xD1BB67F1u,
+       0xA6BC5767u, 0x3FB506DDu, 0x48B2364Bu, 0xD80D2BDAu, 0xAF0A1B4Cu,
+       0x36034AF6u, 0x41047A60u, 0xDF60EFC3u, 0xA867DF55u, 0x316E8EEFu,
+       0x4669BE79u, 0xCB61B38Cu, 0xBC66831Au, 0x256FD2A0u, 0x5268E236u,
+       0xCC0C7795u, 0xBB0B4703u, 0x220216B9u, 0x5505262Fu, 0xC5BA3BBEu,
+       0xB2BD0B28u, 0x2BB45A92u, 0x5CB36A04u, 0xC2D7FFA7u, 0xB5D0CF31u,
+       0x2CD99E8Bu, 0x5BDEAE1Du, 0x9B64C2B0u, 0xEC63F226u, 0x756AA39Cu,
+       0x026D930Au, 0x9C0906A9u, 0xEB0E363Fu, 0x72076785u, 0x05005713u,
+       0x95BF4A82u, 0xE2B87A14u, 0x7BB12BAEu, 0x0CB61B38u, 0x92D28E9Bu,
+       0xE5D5BE0Du, 0x7CDCEFB7u, 0x0BDBDF21u, 0x86D3D2D4u, 0xF1D4E242u,
+       0x68DDB3F8u, 0x1FDA836Eu, 0x81BE16CDu, 0xF6B9265Bu, 0x6FB077E1u,
+       0x18B74777u, 0x88085AE6u, 0xFF0F6A70u, 0x66063BCAu, 0x11010B5Cu,
+       0x8F659EFFu, 0xF862AE69u, 0x616BFFD3u, 0x166CCF45u, 0xA00AE278u,
+       0xD70DD2EEu, 0x4E048354u, 0x3903B3C2u, 0xA7672661u, 0xD06016F7u,
+       0x4969474Du, 0x3E6E77DBu, 0xAED16A4Au, 0xD9D65ADCu, 0x40DF0B66u,
+       0x37D83BF0u, 0xA9BCAE53u, 0xDEBB9EC5u, 0x47B2CF7Fu, 0x30B5FFE9u,
+       0xBDBDF21Cu, 0xCABAC28Au, 0x53B39330u, 0x24B4A3A6u, 0xBAD03605u,
+       0xCDD70693u, 0x54DE5729u, 0x23D967BFu, 0xB3667A2Eu, 0xC4614AB8u,
+       0x5D681B02u, 0x2A6F2B94u, 0xB40BBE37u, 0xC30C8EA1u, 0x5A05DF1Bu,
+       0x2D02EF8Du}},
+     {{0x00000000u, 0x191B3141u, 0x32366282u, 0x2B2D53C3u, 0x646CC504u,
+       0x7D77F445u, 0x565AA786u, 0x4F4196C7u, 0xC8D98A08u, 0xD1C2BB49u,
+       0xFAEFE88Au, 0xE3F4D9CBu, 0xACB54F0Cu, 0xB5AE7E4Du, 0x9E832D8Eu,
+       0x87981CCFu, 0x4AC21251u, 0x53D92310u, 0x78F470D3u, 0x61EF4192u,
+       0x2EAED755u, 0x37B5E614u, 0x1C98B5D7u, 0x05838496u, 0x821B9859u,
+       0x9B00A918u, 0xB02DFADBu, 0xA936CB9Au, 0xE6775D5Du, 0xFF6C6C1Cu,
+       0xD4413FDFu, 0xCD5A0E9Eu, 0x958424A2u, 0x8C9F15E3u, 0xA7B24620u,
+       0xBEA97761u, 0xF1E8E1A6u, 0xE8F3D0E7u, 0xC3DE8324u, 0xDAC5B265u,
+       0x5D5DAEAAu, 0x44469FEBu, 0x6F6BCC28u, 0x7670FD69u, 0x39316BAEu,
+       0x202A5AEFu, 0x0B07092Cu, 0x121C386Du, 0xDF4636F3u, 0xC65D07B2u,
+       0xED705471u, 0xF46B6530u, 0xBB2AF3F7u, 0xA231C2B6u, 0x891C9175u,
+       0x9007A034u, 0x179FBCFBu, 0x0E848DBAu, 0x25A9DE79u, 0x3CB2EF38u,
+       0x73F379FFu, 0x6AE848BEu, 0x41C51B7Du, 0x58DE2A3Cu, 0xF0794F05u,
+       0xE9627E44u, 0xC24F2D87u, 0xDB541CC6u, 0x94158A01u, 0x8D0EBB40u,
+       0xA623E883u, 0xBF38D9C2u, 0x38A0C50Du, 0x21BBF44Cu, 0x0A96A78Fu,
+       0x138D96CEu, 0x5CCC0009u, 0x45D73148u, 0x6EFA628Bu, 0x77E153CAu,
+       0xBABB5D54u, 0xA3A06C15u, 0x888D3FD6u, 0x91960E97u, 0xDED79850u,
+       0xC7CCA911u, 0xECE1FAD2u, 0xF5FACB93u, 0x7262D75Cu, 0x6B79E61Du,
+       0x4054B5DEu, 0x594F849Fu, 0x160E1258u, 0x0F152319u, 0x243870DAu,
+       0x3D23419Bu, 0x65FD6BA7u, 0x7CE65AE6u, 0x57CB0925u, 0x4ED03864u,
+       0x0191AEA3u, 0x188A9FE2u, 0x33A7CC21u, 0x2ABCFD60u, 0xAD24E1AFu,
+       0xB43FD0EEu, 0x9F12832Du, 0x8609B26Cu, 0xC94824ABu, 0xD05315EAu,
+       0xFB7E4629u, 0xE2657768u, 0x2F3F79F6u, 0x362448B7u, 0x1D091B74u,
+       0x04122A35u, 0x4B53BCF2u, 0x52488DB3u, 0x7965DE70u, 0x607EEF31u,
+       0xE7E6F3FEu, 0xFEFDC2BFu, 0xD5D0917Cu, 0xCCCBA03Du, 0x838A36FAu,
+       0x9A9107BBu, 0xB1BC5478u, 0xA8A76539u, 0x3B83984Bu, 0x2298A90Au,
+       0x09B5FAC9u, 0x10AECB88u, 0x5FEF5D4Fu, 0x46F46C0Eu, 0x6DD93FCDu,
+       0x74C20E8Cu, 0xF35A1243u, 0xEA412302u, 0xC16C70C1u, 0xD8774180u,
+       0x9736D747u, 0x8E2DE606u, 0xA500B5C5u, 0xBC1B8484u, 0x71418A1Au,
+       0x685ABB5Bu, 0x4377E898u, 0x5A6CD9D9u, 0x152D4F1Eu, 0x0C367E5Fu,
+       0x271B2D9Cu, 0x3E001CDDu, 0xB9980012u, 0xA0833153u, 0x8BAE6290u,
+       0x92B553D1u, 0xDDF4C516u, 0xC4EFF457u, 0xEFC2A794u, 0xF6D996D5u,
+       0xAE07BCE9u, 0xB71C8DA8u, 0x9C31DE6Bu, 0x852AEF2Au, 0xCA6B79EDu,
+       0xD37048ACu, 0xF85D1B6Fu, 0xE1462A2Eu, 0x66DE36E1u, 0x7FC507A0u,
+       0x54E85463u, 0x4DF36522u, 0x02B2F3E5u, 0x1BA9C2A4u, 0x30849167u,
+       0x299FA026u, 0xE4C5AEB8u, 0xFDDE9FF9u, 0xD6F3CC3Au, 0xCFE8FD7Bu,
+       0x80A96BBCu, 0x99B25AFDu, 0xB29F093Eu, 0xAB84387Fu, 0x2C1C24B0u,
+       0x350715F1u, 0x1E2A4632u, 0x07317773u, 0x4870E1B4u, 0x516BD0F5u,
+       0x7A468336u, 0x635DB277u, 0xCBFAD74Eu, 0xD2E1E60Fu, 0xF9CCB5CCu,
+       0xE0D7848Du, 0xAF96124Au, 0xB68D230Bu, 0x9DA070C8u, 0x84BB4189u,
+       0x03235D46u, 0x1A386C07u, 0x31153FC4u, 0x280E0E85u, 0x674F9842u,
+       0x7E54A903u, 0x5579FAC0u, 0x4C62CB81u, 0x8138C51Fu, 0x9823F45Eu,
+       0xB30EA79Du, 0xAA1596DCu, 0xE554001Bu, 0xFC4F315Au, 0xD7626299u,
+       0xCE7953D8u, 0x49E14F17u, 0x50FA7E56u, 0x7BD72D95u, 0x62CC1CD4u,
+       0x2D8D8A13u, 0x3496BB52u, 0x1FBBE891u, 0x06A0D9D0u, 0x5E7EF3ECu,
+       0x4765C2ADu, 0x6C48916Eu, 0x7553A02Fu, 0x3A1236E8u, 0x230907A9u,
+       0x0824546Au, 0x113F652Bu, 0x96A779E4u, 0x8FBC48A5u, 0xA4911B66u,
+       0xBD8A2A27u, 0xF2CBBCE0u, 0xEBD08DA1u, 0xC0FDDE62u, 0xD9E6EF23u,
+       0x14BCE1BDu, 0x0DA7D0FCu, 0x268A833Fu, 0x3F91B27Eu, 0x70D024B9u,
+       0x69CB15F8u, 0x42E6463Bu, 0x5BFD777Au, 0xDC656BB5u, 0xC57E5AF4u,
+       0xEE530937u, 0xF7483876u, 0xB809AEB1u, 0xA1129FF0u, 0x8A3FCC33u,
+       0x9324FD72u}},
+     {{0x00000000u, 0x01C26A37u, 0x0384D46Eu, 0x0246BE59u, 0x0709A8DCu,
+       0x06CBC2EBu, 0x048D7CB2u, 0x054F1685u, 0x0E1351B8u, 0x0FD13B8Fu,
+       0x0D9785D6u, 0x0C55EFE1u, 0x091AF964u, 0x08D89353u, 0x0A9E2D0Au,
+       0x0B5C473Du, 0x1C26A370u, 0x1DE4C947u, 0x1FA2771Eu, 0x1E601D29u,
+       0x1B2F0BACu, 0x1AED619Bu, 0x18ABDFC2u, 0x1969B5F5u, 0x1235F2C8u,
+       0x13F798FFu, 0x11B126A6u, 0x10734C91u, 0x153C5A14u, 0x14FE3023u,
+       0x16B88E7Au, 0x177AE44Du, 0x384D46E0u, 0x398F2CD7u, 0x3BC9928Eu,
+       0x3A0BF8B9u, 0x3F44EE3Cu, 0x3E86840Bu, 0x3CC03A52u, 0x3D025065u,
+       0x365E1758u, 0x379C7D6Fu, 0x35DAC336u, 0x3418A901u, 0x3157BF84u,
+       0x3095D5B3u, 0x32D36BEAu, 0x331101DDu, 0x246BE590u, 0x25A98FA7u,
+       0x27EF31FEu, 0x262D5BC9u, 0x23624D4Cu, 0x22A0277Bu, 0x20E69922u,
+       0x2124F315u, 0x2A78B428u, 0x2BBADE1Fu, 0x29FC6046u, 0x283E0A71u,
+       0x2D711CF4u, 0x2CB376C3u, 0x2EF5C89Au, 0x2F37A2ADu, 0x709A8DC0u,
+       0x7158E7F7u, 0x731E59AEu, 0x72DC3399u, 0x7793251Cu, 0x76514F2Bu,
+       0x7417F172u, 0x75D59B45u, 0x7E89DC78u, 0x7F4BB64Fu, 0x7D0D0816u,
+       0x7CCF6221u, 0x798074A4u, 0x78421E93u, 0x7A04A0CAu, 0x7BC6CAFDu,
+       0x6CBC2EB0u, 0x6D7E4487u, 0x6F38FADEu, 0x6EFA90E9u, 0x6BB5866Cu,
+       0x6A77EC5Bu, 0x68315202u, 0x69F33835u, 0x62AF7F08u, 0x636D153Fu,
+       0x612BAB66u, 0x60E9C151u, 0x65A6D7D4u, 0x6464BDE3u, 0x662203BAu,
+       0x67E0698Du, 0x48D7CB20u, 0x4915A117u, 0x4B531F4Eu, 0x4A917579u,
+       0x4FDE63FCu, 0x4E1C09CBu, 0x4C5AB792u, 0x4D98DDA5u, 0x46C49A98u,
+       0x4706F0AFu, 0x45404EF6u, 0x448224C1u, 0x41CD3244u, 0x400F5873u,
+       0x4249E62Au, 0x438B8C1Du, 0x54F16850u, 0x55330267u, 0x5775BC3Eu,
+       0x56B7D609u, 0x53F8C08Cu, 0x523AAABBu, 0x507C14E2u, 0x51BE7ED5u,
+       0x5AE239E8u, 0x5B2053DFu, 0x5966ED86u, 0x58A487B1u, 0x5DEB9134u,
+       0x5C29FB03u, 0x5E6F455Au, 0x5FAD2F6Du, 0xE1351B80u, 0xE0F771B7u,
+       0xE2B1CFEEu, 0xE373A5D9u, 0xE63CB35Cu, 0xE7FED96Bu, 0xE5B86732u,
+       0xE47A0D05u, 0xEF264A38u, 0xEEE4200Fu, 0xECA29E56u, 0xED60F461u,
+       0xE82FE2E4u, 0xE9ED88D3u, 0xEBAB368Au, 0xEA695CBDu, 0xFD13B8F0u,
+       0xFCD1D2C7u, 0xFE976C9Eu, 0xFF5506A9u, 0xFA1A102Cu, 0xFBD87A1Bu,
+       0xF99EC442u, 0xF85CAE75u, 0xF300E948u, 0xF2C2837Fu, 0xF0843D26u,
+       0xF1465711u, 0xF4094194u, 0xF5CB2BA3u, 0xF78D95FAu, 0xF64FFFCDu,
+       0xD9785D60u, 0xD8BA3757u, 0xDAFC890Eu, 0xDB3EE339u, 0xDE71F5BCu,
+       0xDFB39F8Bu, 0xDDF521D2u, 0xDC374BE5u, 0xD76B0CD8u, 0xD6A966EFu,
+       0xD4EFD8B6u, 0xD52DB281u, 0xD062A404u, 0xD1A0CE33u, 0xD3E6706Au,
+       0xD2241A5Du, 0xC55EFE10u, 0xC49C9427u, 0xC6DA2A7Eu, 0xC7184049u,
+       0xC25756CCu, 0xC3953CFBu, 0xC1D382A2u, 0xC011E895u, 0xCB4DAFA8u,
+       0xCA8FC59Fu, 0xC8C97BC6u, 0xC90B11F1u, 0xCC440774u, 0xCD866D43u,
+       0xCFC0D31Au, 0xCE02B92Du, 0x91AF9640u, 0x906DFC77u, 0x922B422Eu,
+       0x93E92819u, 0x96A63E9Cu, 0x976454ABu, 0x9522EAF2u, 0x94E080C5u,
+       0x9FBCC7F8u, 0x9E7EADCFu, 0x9C381396u, 0x9DFA79A1u, 0x98B56F24u,
+       0x99770513u, 0x9B31BB4Au, 0x9AF3D17Du, 0x8D893530u, 0x8C4B5F07u,
+       0x8E0DE15Eu, 0x8FCF8B69u, 0x8A809DECu, 0x8B42F7DBu, 0x89044982u,
+       0x88C623B5u, 0x839A6488u, 0x82580EBFu, 0x801EB0E6u, 0x81DCDAD1u,
+       0x8493CC54u, 0x8551A663u, 0x8717183Au, 0x86D5720Du, 0xA9E2D0A0u,
+       0xA820BA97u, 0xAA6604CEu, 0xABA46EF9u, 0xAEEB787Cu, 0xAF29124Bu,
+       0xAD6FAC12u, 0xACADC625u, 0xA7F18118u, 0xA633EB2Fu, 0xA4755576u,
+       0xA5B73F41u, 0xA0F829C4u, 0xA13A43F3u, 0xA37CFDAAu, 0xA2BE979Du,
+       0xB5C473D0u, 0xB40619E7u, 0xB640A7BEu, 0xB782CD89u, 0xB2CDDB0Cu,
+       0xB30FB13Bu, 0xB1490F62u, 0xB08B6555u, 0xBBD72268u, 0xBA15485Fu,
+       0xB853F606u, 0xB9919C31u, 0xBCDE8AB4u, 0xBD1CE083u, 0xBF5A5EDAu,
+       0xBE9834EDu}},
+     {{0x00000000u, 0xB8BC6765u, 0xAA09C88Bu, 0x12B5AFEEu, 0x8F629757u,
+       0x37DEF032u, 0x256B5FDCu, 0x9DD738B9u, 0xC5B428EFu, 0x7D084F8Au,
+       0x6FBDE064u, 0xD7018701u, 0x4AD6BFB8u, 0xF26AD8DDu, 0xE0DF7733u,
+       0x58631056u, 0x5019579Fu, 0xE8A530FAu, 0xFA109F14u, 0x42ACF871u,
+       0xDF7BC0C8u, 0x67C7A7ADu, 0x75720843u, 0xCDCE6F26u, 0x95AD7F70u,
+       0x2D111815u, 0x3FA4B7FBu, 0x8718D09Eu, 0x1ACFE827u, 0xA2738F42u,
+       0xB0C620ACu, 0x087A47C9u, 0xA032AF3Eu, 0x188EC85Bu, 0x0A3B67B5u,
+       0xB28700D0u, 0x2F503869u, 0x97EC5F0Cu, 0x8559F0E2u, 0x3DE59787u,
+       0x658687D1u, 0xDD3AE0B4u, 0xCF8F4F5Au, 0x7733283Fu, 0xEAE41086u,
+       0x525877E3u, 0x40EDD80Du, 0xF851BF68u, 0xF02BF8A1u, 0x48979FC4u,
+       0x5A22302Au, 0xE29E574Fu, 0x7F496FF6u, 0xC7F50893u, 0xD540A77Du,
+       0x6DFCC018u, 0x359FD04Eu, 0x8D23B72Bu, 0x9F9618C5u, 0x272A7FA0u,
+       0xBAFD4719u, 0x0241207Cu, 0x10F48F92u, 0xA848E8F7u, 0x9B14583Du,
+       0x23A83F58u, 0x311D90B6u, 0x89A1F7D3u, 0x1476CF6Au, 0xACCAA80Fu,
+       0xBE7F07E1u, 0x06C36084u, 0x5EA070D2u, 0xE61C17B7u, 0xF4A9B859u,
+       0x4C15DF3Cu, 0xD1C2E785u, 0x697E80E0u, 0x7BCB2F0Eu, 0xC377486Bu,
+       0xCB0D0FA2u, 0x73B168C7u, 0x6104C729u, 0xD9B8A04Cu, 0x446F98F5u,
+       0xFCD3FF90u, 0xEE66507Eu, 0x56DA371Bu, 0x0EB9274Du, 0xB6054028u,
+       0xA4B0EFC6u, 0x1C0C88A3u, 0x81DBB01Au, 0x3967D77Fu, 0x2BD27891u,
+       0x936E1FF4u, 0x3B26F703u, 0x839A9066u, 0x912F3F88u, 0x299358EDu,
+       0xB4446054u, 0x0CF80731u, 0x1E4DA8DFu, 0xA6F1CFBAu, 0xFE92DFECu,
+       0x462EB889u, 0x549B1767u, 0xEC277002u, 0x71F048BBu, 0xC94C2FDEu,
+       0xDBF98030u, 0x6345E755u, 0x6B3FA09Cu, 0xD383C7F9u, 0xC1366817u,
+       0x798A0F72u, 0xE45D37CBu, 0x5CE150AEu, 0x4E54FF40u, 0xF6E89825u,
+       0xAE8B8873u, 0x1637EF16u, 0x048240F8u, 0xBC3E279Du, 0x21E91F24u,
+       0x99557841u, 0x8BE0D7AFu, 0x335CB0CAu, 0xED59B63Bu, 0x55E5D15Eu,
+       0x47507EB0u, 0xFFEC19D5u, 0x623B216Cu, 0xDA874609u, 0xC832E9E7u,
+       0x708E8E82u, 0x28ED9ED4u, 0x9051F9B1u, 0x82E4565Fu, 0x3A58313Au,
+       0xA78F0983u, 0x1F336EE6u, 0x0D86C108u, 0xB53AA66Du, 0xBD40E1A4u,
+       0x05FC86C1u, 0x1749292Fu, 0xAFF54E4Au, 0x322276F3u, 0x8A9E1196u,
+       0x982BBE78u, 0x2097D91Du, 0x78F4C94Bu, 0xC048AE2Eu, 0xD2FD01C0u,
+       0x6A4166A5u, 0xF7965E1Cu, 0x4F2A3979u, 0x5D9F9697u, 0xE523F1F2u,
+       0x4D6B1905u, 0xF5D77E60u, 0xE762D18Eu, 0x5FDEB6EBu, 0xC2098E52u,
+       0x7AB5E937u, 0x680046D9u, 0xD0BC21BCu, 0x88DF31EAu, 0x3063568Fu,
+       0x22D6F961u, 0x9A6A9E04u, 0x07BDA6BDu, 0xBF01C1D8u, 0xADB46E36u,
+       0x15080953u, 0x1D724E9Au, 0xA5CE29FFu, 0xB77B8611u, 0x0FC7E174u,
+       0x9210D9CDu, 0x2AACBEA8u, 0x38191146u, 0x80A57623u, 0xD8C66675u,
+       0x607A0110u, 0x72CFAEFEu, 0xCA73C99Bu, 0x57A4F122u, 0xEF189647u,
+       0xFDAD39A9u, 0x45115ECCu, 0x764DEE06u, 0xCEF18963u, 0xDC44268Du,
+       0x64F841E8u, 0xF92F7951u, 0x41931E34u, 0x5326B1DAu, 0xEB9AD6BFu,
+       0xB3F9C6E9u, 0x0B45A18Cu, 0x19F00E62u, 0xA14C6907u, 0x3C9B51BEu,
+       0x842736DBu, 0x96929935u, 0x2E2EFE50u, 0x2654B999u, 0x9EE8DEFCu,
+       0x8C5D7112u, 0x34E11677u, 0xA9362ECEu, 0x118A49ABu, 0x033FE645u,
+       0xBB838120u, 0xE3E09176u, 0x5B5CF613u, 0x49E959FDu, 0xF1553E98u,
+       0x6C820621u, 0xD43E6144u, 0xC68BCEAAu, 0x7E37A9CFu, 0xD67F4138u,
+       0x6EC3265Du, 0x7C7689B3u, 0xC4CAEED6u, 0x591DD66Fu, 0xE1A1B10Au,
+       0xF3141EE4u, 0x4BA87981u, 0x13CB69D7u, 0xAB770EB2u, 0xB9C2A15Cu,
+       0x017EC639u, 0x9CA9FE80u, 0x241599E5u, 0x36A0360Bu, 0x8E1C516Eu,
+       0x866616A7u, 0x3EDA71C2u, 0x2C6FDE2Cu, 0x94D3B949u, 0x090481F0u,
+       0xB1B8E695u, 0xA30D497Bu, 0x1BB12E1Eu, 0x43D23E48u, 0xFB6E592Du,
+       0xE9DBF6C3u, 0x516791A6u, 0xCCB0A91Fu, 0x740CCE7Au, 0x66B96194u,
+       0xDE0506F1u}},
+     {{0x00000000u, 0x3D6029B0u, 0x7AC05360u, 0x47A07AD0u, 0xF580A6C0u,
+       0xC8E08F70u, 0x8F40F5A0u, 0xB220DC10u, 0x30704BC1u, 0x0D106271u,
+       0x4AB018A1u, 0x77D03111u, 0xC5F0ED01u, 0xF890C4B1u, 0xBF30BE61u,
+       0x825097D1u, 0x60E09782u, 0x5D80BE32u, 0x1A20C4E2u, 0x2740ED52u,
+       0x95603142u, 0xA80018F2u, 0xEFA06222u, 0xD2C04B92u, 0x5090DC43u,
+       0x6DF0F5F3u, 0x2A508F23u, 0x1730A693u, 0xA5107A83u, 0x98705333u,
+       0xDFD029E3u, 0xE2B00053u, 0xC1C12F04u, 0xFCA106B4u, 0xBB017C64u,
+       0x866155D4u, 0x344189C4u, 0x0921A074u, 0x4E81DAA4u, 0x73E1F314u,
+       0xF1B164C5u, 0xCCD14D75u, 0x8B7137A5u, 0xB6111E15u, 0x0431C205u,
+       0x3951EBB5u, 0x7EF19165u, 0x4391B8D5u, 0xA121B886u, 0x9C419136u,
+       0xDBE1EBE6u, 0xE681C256u, 0x54A11E46u, 0x69C137F6u, 0x2E614D26u,
+       0x13016496u, 0x9151F347u, 0xAC31DAF7u, 0xEB91A027u, 0xD6F18997u,
+       0x64D15587u, 0x59B17C37u, 0x1E1106E7u, 0x23712F57u, 0x58F35849u,
+       0x659371F9u, 0x22330B29u, 0x1F532299u, 0xAD73FE89u, 0x9013D739u,
+       0xD7B3ADE9u, 0xEAD38459u, 0x68831388u, 0x55E33A38u, 0x124340E8u,
+       0x2F236958u, 0x9D03B548u, 0xA0639CF8u, 0xE7C3E628u, 0xDAA3CF98u,
+       0x3813CFCBu, 0x0573E67Bu, 0x42D39CABu, 0x7FB3B51Bu, 0xCD93690Bu,
+       0xF0F340BBu, 0xB7533A6Bu, 0x8A3313DBu, 0x0863840Au, 0x3503ADBAu,
+       0x72A3D76Au, 0x4FC3FEDAu, 0xFDE322CAu, 0xC0830B7Au, 0x872371AAu,
+       0xBA43581Au, 0x9932774Du, 0xA4525EFDu, 0xE3F2242Du, 0xDE920D9Du,
+       0x6CB2D18Du, 0x51D2F83Du, 0x167282EDu, 0x2B12AB5Du, 0xA9423C8Cu,
+       0x9422153Cu, 0xD3826FECu, 0xEEE2465Cu, 0x5CC29A4Cu, 0x61A2B3FCu,
+       0x2602C92Cu, 0x1B62E09Cu, 0xF9D2E0CFu, 0xC4B2C97Fu, 0x8312B3AFu,
+       0xBE729A1Fu, 0x0C52460Fu, 0x31326FBFu, 0x7692156Fu, 0x4BF23CDFu,
+       0xC9A2AB0Eu, 0xF4C282BEu, 0xB362F86Eu, 0x8E02D1DEu, 0x3C220DCEu,
+       0x0142247Eu, 0x46E25EAEu, 0x7B82771Eu, 0xB1E6B092u, 0x8C869922u,
+       0xCB26E3F2u, 0xF646CA42u, 0x44661652u, 0x79063FE2u, 0x3EA64532u,
+       0x03C66C82u, 0x8196FB53u, 0xBCF6D2E3u, 0xFB56A833u, 0xC6368183u,
+       0x74165D93u, 0x49767423u, 0x0ED60EF3u, 0x33B62743u, 0xD1062710u,
+       0xEC660EA0u, 0xABC67470u, 0x96A65DC0u, 0x248681D0u, 0x19E6A860u,
+       0x5E46D2B0u, 0x6326FB00u, 0xE1766CD1u, 0xDC164561u, 0x9BB63FB1u,
+       0xA6D61601u, 0x14F6CA11u, 0x2996E3A1u, 0x6E369971u, 0x5356B0C1u,
+       0x70279F96u, 0x4D47B626u, 0x0AE7CCF6u, 0x3787E546u, 0x85A73956u,
+       0xB8C710E6u, 0xFF676A36u, 0xC2074386u, 0x4057D457u, 0x7D37FDE7u,
+       0x3A978737u, 0x07F7AE87u, 0xB5D77297u, 0x88B75B27u, 0xCF1721F7u,
+       0xF2770847u, 0x10C70814u, 0x2DA721A4u, 0x6A075B74u, 0x576772C4u,
+       0xE547AED4u, 0xD8278764u, 0x9F87FDB4u, 0xA2E7D404u, 0x20B743D5u,
+       0x1DD76A65u, 0x5A7710B5u, 0x67173905u, 0xD537E515u, 0xE857CCA5u,
+       0xAFF7B675u, 0x92979FC5u, 0xE915E8DBu, 0xD475C16Bu, 0x93D5BBBBu,
+       0xAEB5920Bu, 0x1C954E1Bu, 0x21F567ABu, 0x66551D7Bu, 0x5B3534CBu,
+       0xD965A31Au, 0xE4058AAAu, 0xA3A5F07Au, 0x9EC5D9CAu, 0x2CE505DAu,
+       0x11852C6Au, 0x562556BAu, 0x6B457F0Au, 0x89F57F59u, 0xB49556E9u,
+       0xF3352C39u, 0xCE550589u, 0x7C75D999u, 0x4115F029u, 0x06B58AF9u,
+       0x3BD5A349u, 0xB9853498u, 0x84E51D28u, 0xC34567F8u, 0xFE254E48u,
+       0x4C059258u, 0x7165BBE8u, 0x36C5C138u, 0x0BA5E888u, 0x28D4C7DFu,
+       0x15B4EE6Fu, 0x521494BFu, 0x6F74BD0Fu, 0xDD54611Fu, 0xE03448AFu,
+       0xA794327Fu, 0x9AF41BCFu, 0x18A48C1Eu, 0x25C4A5AEu, 0x6264DF7Eu,
+       0x5F04F6CEu, 0xED242ADEu, 0xD044036Eu, 0x97E479BEu, 0xAA84500Eu,
+       0x4834505Du, 0x755479EDu, 0x32F4033Du, 0x0F942A8Du, 0xBDB4F69Du,
+       0x80D4DF2Du, 0xC774A5FDu, 0xFA148C4Du, 0x78441B9Cu, 0x4524322Cu,
+       0x028448FCu, 0x3FE4614Cu, 0x8DC4BD5Cu, 0xB0A494ECu, 0xF704EE3Cu,
+       0xCA64C78Cu}},
+     {{0x00000000u, 0xCB5CD3A5u, 0x4DC8A10Bu, 0x869472AEu, 0x9B914216u,
+       0x50CD91B3u, 0xD659E31Du, 0x1D0530B8u, 0xEC53826Du, 0x270F51C8u,
+       0xA19B2366u, 0x6AC7F0C3u, 0x77C2C07Bu, 0xBC9E13DEu, 0x3A0A6170u,
+       0xF156B2D5u, 0x03D6029Bu, 0xC88AD13Eu, 0x4E1EA390u, 0x85427035u,
+       0x9847408Du, 0x531B9328u, 0xD58FE186u, 0x1ED33223u, 0xEF8580F6u,
+       0x24D95353u, 0xA24D21FDu, 0x6911F258u, 0x7414C2E0u, 0xBF481145u,
+       0x39DC63EBu, 0xF280B04Eu, 0x07AC0536u, 0xCCF0D693u, 0x4A64A43Du,
+       0x81387798u, 0x9C3D4720u, 0x57619485u, 0xD1F5E62Bu, 0x1AA9358Eu,
+       0xEBFF875Bu, 0x20A354FEu, 0xA6372650u, 0x6D6BF5F5u, 0x706EC54Du,
+       0xBB3216E8u, 0x3DA66446u, 0xF6FAB7E3u, 0x047A07ADu, 0xCF26D408u,
+       0x49B2A6A6u, 0x82EE7503u, 0x9FEB45BBu, 0x54B7961Eu, 0xD223E4B0u,
+       0x197F3715u, 0xE82985C0u, 0x23755665u, 0xA5E124CBu, 0x6EBDF76Eu,
+       0x73B8C7D6u, 0xB8E41473u, 0x3E7066DDu, 0xF52CB578u, 0x0F580A6Cu,
+       0xC404D9C9u, 0x4290AB67u, 0x89CC78C2u, 0x94C9487Au, 0x5F959BDFu,
+       0xD901E971u, 0x125D3AD4u, 0xE30B8801u, 0x28575BA4u, 0xAEC3290Au,
+       0x659FFAAFu, 0x789ACA17u, 0xB3C619B2u, 0x35526B1Cu, 0xFE0EB8B9u,
+       0x0C8E08F7u, 0xC7D2DB52u, 0x4146A9FCu, 0x8A1A7A59u, 0x971F4AE1u,
+       0x5C439944u, 0xDAD7EBEAu, 0x118B384Fu, 0xE0DD8A9Au, 0x2B81593Fu,
+       0xAD152B91u, 0x6649F834u, 0x7B4CC88Cu, 0xB0101B29u, 0x36846987u,
+       0xFDD8BA22u, 0x08F40F5Au, 0xC3A8DCFFu, 0x453CAE51u, 0x8E607DF4u,
+       0x93654D4Cu, 0x58399EE9u, 0xDEADEC47u, 0x15F13FE2u, 0xE4A78D37u,
+       0x2FFB5E92u, 0xA96F2C3Cu, 0x6233FF99u, 0x7F36CF21u, 0xB46A1C84u,
+       0x32FE6E2Au, 0xF9A2BD8Fu, 0x0B220DC1u, 0xC07EDE64u, 0x46EAACCAu,
+       0x8DB67F6Fu, 0x90B34FD7u, 0x5BEF9C72u, 0xDD7BEEDCu, 0x16273D79u,
+       0xE7718FACu, 0x2C2D5C09u, 0xAAB92EA7u, 0x61E5FD02u, 0x7CE0CDBAu,
+       0xB7BC1E1Fu, 0x31286CB1u, 0xFA74BF14u, 0x1EB014D8u, 0xD5ECC77Du,
+       0x5378B5D3u, 0x98246676u, 0x852156CEu, 0x4E7D856Bu, 0xC8E9F7C5u,
+       0x03B52460u, 0xF2E396B5u, 0x39BF4510u, 0xBF2B37BEu, 0x7477E41Bu,
+       0x6972D4A3u, 0xA22E0706u, 0x24BA75A8u, 0xEFE6A60Du, 0x1D661643u,
+       0xD63AC5E6u, 0x50AEB748u, 0x9BF264EDu, 0x86F75455u, 0x4DAB87F0u,
+       0xCB3FF55Eu, 0x006326FBu, 0xF135942Eu, 0x3A69478Bu, 0xBCFD3525u,
+       0x77A1E680u, 0x6AA4D638u, 0xA1F8059Du, 0x276C7733u, 0xEC30A496u,
+       0x191C11EEu, 0xD240C24Bu, 0x54D4B0E5u, 0x9F886340u, 0x828D53F8u,
+       0x49D1805Du, 0xCF45F2F3u, 0x04192156u, 0xF54F9383u, 0x3E134026u,
+       0xB8873288u, 0x73DBE12Du, 0x6EDED195u, 0xA5820230u, 0x2316709Eu,
+       0xE84AA33Bu, 0x1ACA1375u, 0xD196C0D0u, 0x5702B27Eu, 0x9C5E61DBu,
+       0x815B5163u, 0x4A0782C6u, 0xCC93F068u, 0x07CF23CDu, 0xF6999118u,
+       0x3DC542BDu, 0xBB513013u, 0x700DE3B6u, 0x6D08D30Eu, 0xA65400ABu,
+       0x20C07205u, 0xEB9CA1A0u, 0x11E81EB4u, 0xDAB4CD11u, 0x5C20BFBFu,
+       0x977C6C1Au, 0x8A795CA2u, 0x41258F07u, 0xC7B1FDA9u, 0x0CED2E0Cu,
+       0xFDBB9CD9u, 0x36E74F7Cu, 0xB0733DD2u, 0x7B2FEE77u, 0x662ADECFu,
+       0xAD760D6Au, 0x2BE27FC4u, 0xE0BEAC61u, 0x123E1C2Fu, 0xD962CF8Au,
+       0x5FF6BD24u, 0x94AA6E81u, 0x89AF5E39u, 0x42F38D9Cu, 0xC467FF32u,
+       0x0F3B2C97u, 0xFE6D9E42u, 0x35314DE7u, 0xB3A53F49u, 0x78F9ECECu,
+       0x65FCDC54u, 0xAEA00FF1u, 0x28347D5Fu, 0xE368AEFAu, 0x16441B82u,
+       0xDD18C827u, 0x5B8CBA89u, 0x90D0692Cu, 0x8DD55994u, 0x46898A31u,
+       0xC01DF89Fu, 0x0B412B3Au, 0xFA1799EFu, 0x314B4A4Au, 0xB7DF38E4u,
+       0x7C83EB41u, 0x6186DBF9u, 0xAADA085Cu, 0x2C4E7AF2u, 0xE712A957u,
+       0x15921919u, 0xDECECABCu, 0x585AB812u, 0x93066BB7u, 0x8E035B0Fu,
+       0x455F88AAu, 0xC3CBFA04u, 0x089729A1u, 0xF9C19B74u, 0x329D48D1u,
+       0xB4093A7Fu, 0x7F55E9DAu, 0x6250D962u, 0xA90C0AC7u, 0x2F987869u,
+       0xE4C4ABCCu}},
+     {{0x00000000u, 0xA6770BB4u, 0x979F1129u, 0x31E81A9Du, 0xF44F2413u,
+       0x52382FA7u, 0x63D0353Au, 0xC5A73E8Eu, 0x33EF4E67u, 0x959845D3u,
+       0xA4705F4Eu, 0x020754FAu, 0xC7A06A74u, 0x61D761C0u, 0x503F7B5Du,
+       0xF64870E9u, 0x67DE9CCEu, 0xC1A9977Au, 0xF0418DE7u, 0x56368653u,
+       0x9391B8DDu, 0x35E6B369u, 0x040EA9F4u, 0xA279A240u, 0x5431D2A9u,
+       0xF246D91Du, 0xC3AEC380u, 0x65D9C834u, 0xA07EF6BAu, 0x0609FD0Eu,
+       0x37E1E793u, 0x9196EC27u, 0xCFBD399Cu, 0x69CA3228u, 0x582228B5u,
+       0xFE552301u, 0x3BF21D8Fu, 0x9D85163Bu, 0xAC6D0CA6u, 0x0A1A0712u,
+       0xFC5277FBu, 0x5A257C4Fu, 0x6BCD66D2u, 0xCDBA6D66u, 0x081D53E8u,
+       0xAE6A585Cu, 0x9F8242C1u, 0x39F54975u, 0xA863A552u, 0x0E14AEE6u,
+       0x3FFCB47Bu, 0x998BBFCFu, 0x5C2C8141u, 0xFA5B8AF5u, 0xCBB39068u,
+       0x6DC49BDCu, 0x9B8CEB35u, 0x3DFBE081u, 0x0C13FA1Cu, 0xAA64F1A8u,
+       0x6FC3CF26u, 0xC9B4C492u, 0xF85CDE0Fu, 0x5E2BD5BBu, 0x440B7579u,
+       0xE27C7ECDu, 0xD3946450u, 0x75E36FE4u, 0xB044516Au, 0x16335ADEu,
+       0x27DB4043u, 0x81AC4BF7u, 0x77E43B1Eu, 0xD19330AAu, 0xE07B2A37u,
+       0x460C2183u, 0x83AB1F0Du, 0x25DC14B9u, 0x14340E24u, 0xB2430590u,
+       0x23D5E9B7u, 0x85A2E203u, 0xB44AF89Eu, 0x123DF32Au, 0xD79ACDA4u,
+       0x71EDC610u, 0x4005DC8Du, 0xE672D739u, 0x103AA7D0u, 0xB64DAC64u,
+       0x87A5B6F9u, 0x21D2BD4Du, 0xE47583C3u, 0x42028877u, 0x73EA92EAu,
+       0xD59D995Eu, 0x8BB64CE5u, 0x2DC14751u, 0x1C295DCCu, 0xBA5E5678u,
+       0x7FF968F6u, 0xD98E6342u, 0xE86679DFu, 0x4E11726Bu, 0xB8590282u,
+       0x1E2E0936u, 0x2FC613ABu, 0x89B1181Fu, 0x4C162691u, 0xEA612D25u,
+       0xDB8937B8u, 0x7DFE3C0Cu, 0xEC68D02Bu, 0x4A1FDB9Fu, 0x7BF7C102u,
+       0xDD80CAB6u, 0x1827F438u, 0xBE50FF8Cu, 0x8FB8E511u, 0x29CFEEA5u,
+       0xDF879E4Cu, 0x79F095F8u, 0x48188F65u, 0xEE6F84D1u, 0x2BC8BA5Fu,
+       0x8DBFB1EBu, 0xBC57AB76u, 0x1A20A0C2u, 0x8816EAF2u, 0x2E61E146u,
+       0x1F89FBDBu, 0xB9FEF06Fu, 0x7C59CEE1u, 0xDA2EC555u, 0xEBC6DFC8u,
+       0x4DB1D47Cu, 0xBBF9A495u, 0x1D8EAF21u, 0x2C66B5BCu, 0x8A11BE08u,
+       0x4FB68086u, 0xE9C18B32u, 0xD82991AFu, 0x7E5E9A1Bu, 0xEFC8763Cu,
+       0x49BF7D88u, 0x78576715u, 0xDE206CA1u, 0x1B87522Fu, 0xBDF0599Bu,
+       0x8C184306u, 0x2A6F48B2u, 0xDC27385Bu, 0x7A5033EFu, 0x4BB82972u,
+       0xEDCF22C6u, 0x28681C48u, 0x8E1F17FCu, 0xBFF70D61u, 0x198006D5u,
+       0x47ABD36Eu, 0xE1DCD8DAu, 0xD034C247u, 0x7643C9F3u, 0xB3E4F77Du,
+       0x1593FCC9u, 0x247BE654u, 0x820CEDE0u, 0x74449D09u, 0xD23396BDu,
+       0xE3DB8C20u, 0x45AC8794u, 0x800BB91Au, 0x267CB2AEu, 0x1794A833u,
+       0xB1E3A387u, 0x20754FA0u, 0x86024414u, 0xB7EA5E89u, 0x119D553Du,
+       0xD43A6BB3u, 0x724D6007u, 0x43A57A9Au, 0xE5D2712Eu, 0x139A01C7u,
+       0xB5ED0A73u, 0x840510EEu, 0x22721B5Au, 0xE7D525D4u, 0x41A22E60u,
+       0x704A34FDu, 0xD63D3F49u, 0xCC1D9F8Bu, 0x6A6A943Fu, 0x5B828EA2u,
+       0xFDF58516u, 0x3852BB98u, 0x9E25B02Cu, 0xAFCDAAB1u, 0x09BAA105u,
+       0xFFF2D1ECu, 0x5985DA58u, 0x686DC0C5u, 0xCE1ACB71u, 0x0BBDF5FFu,
+       0xADCAFE4Bu, 0x9C22E4D6u, 0x3A55EF62u, 0xABC30345u, 0x0DB408F1u,
+       0x3C5C126Cu, 0x9A2B19D8u, 0x5F8C2756u, 0xF9FB2CE2u, 0xC813367Fu,
+       0x6E643DCBu, 0x982C4D22u, 0x3E5B4696u, 0x0FB35C0Bu, 0xA9C457BFu,
+       0x6C636931u, 0xCA146285u, 0xFBFC7818u, 0x5D8B73ACu, 0x03A0A617u,
+       0xA5D7ADA3u, 0x943FB73Eu, 0x3248BC8Au, 0xF7EF8204u, 0x519889B0u,
+       0x6070932Du, 0xC6079899u, 0x304FE870u, 0x9638E3C4u, 0xA7D0F959u,
+       0x01A7F2EDu, 0xC400CC63u, 0x6277C7D7u, 0x539FDD4Au, 0xF5E8D6FEu,
+       0x647E3AD9u, 0xC209316Du, 0xF3E12BF0u, 0x55962044u, 0x90311ECAu,
+       0x3646157Eu, 0x07AE0FE3u, 0xA1D90457u, 0x579174BEu, 0xF1E67F0Au,
+       0xC00E6597u, 0x66796E23u, 0xA3DE50ADu, 0x05A95B19u, 0x34414184u,
+       0x92364A30u}},
+     {{0x00000000u, 0xCCAA009Eu, 0x4225077Du, 0x8E8F07E3u, 0x844A0EFAu,
+       0x48E00E64u, 0xC66F0987u, 0x0AC50919u, 0xD3E51BB5u, 0x1F4F1B2Bu,
+       0x91C01CC8u, 0x5D6A1C56u, 0x57AF154Fu, 0x9B0515D1u, 0x158A1232u,
+       0xD92012ACu, 0x7CBB312Bu, 0xB01131B5u, 0x3E9E3656u, 0xF23436C8u,
+       0xF8F13FD1u, 0x345B3F4Fu, 0xBAD438ACu, 0x767E3832u, 0xAF5E2A9Eu,
+       0x63F42A00u, 0xED7B2DE3u, 0x21D12D7Du, 0x2B142464u, 0xE7BE24FAu,
+       0x69312319u, 0xA59B2387u, 0xF9766256u, 0x35DC62C8u, 0xBB53652Bu,
+       0x77F965B5u, 0x7D3C6CACu, 0xB1966C32u, 0x3F196BD1u, 0xF3B36B4Fu,
+       0x2A9379E3u, 0xE639797Du, 0x68B67E9Eu, 0xA41C7E00u, 0xAED97719u,
+       0x62737787u, 0xECFC7064u, 0x205670FAu, 0x85CD537Du, 0x496753E3u,
+       0xC7E85400u, 0x0B42549Eu, 0x01875D87u, 0xCD2D5D19u, 0x43A25AFAu,
+       0x8F085A64u, 0x562848C8u, 0x9A824856u, 0x140D4FB5u, 0xD8A74F2Bu,
+       0xD2624632u, 0x1EC846ACu, 0x9047414Fu, 0x5CED41D1u, 0x299DC2EDu,
+       0xE537C273u, 0x6BB8C590u, 0xA712C50Eu, 0xADD7CC17u, 0x617DCC89u,
+       0xEFF2CB6Au, 0x2358CBF4u, 0xFA78D958u, 0x36D2D9C6u, 0xB85DDE25u,
+       0x74F7DEBBu, 0x7E32D7A2u, 0xB298D73Cu, 0x3C17D0DFu, 0xF0BDD041u,
+       0x5526F3C6u, 0x998CF358u, 0x1703F4BBu, 0xDBA9F425u, 0xD16CFD3Cu,
+       0x1DC6FDA2u, 0x9349FA41u, 0x5FE3FADFu, 0x86C3E873u, 0x4A69E8EDu,
+       0xC4E6EF0Eu, 0x084CEF90u, 0x0289E689u, 0xCE23E617u, 0x40ACE1F4u,
+       0x8C06E16Au, 0xD0EBA0BBu, 0x1C41A025u, 0x92CEA7C6u, 0x5E64A758u,
+       0x54A1AE41u, 0x980BAEDFu, 0x1684A93Cu, 0xDA2EA9A2u, 0x030EBB0Eu,
+       0xCFA4BB90u, 0x412BBC73u, 0x8D81BCEDu, 0x8744B5F4u, 0x4BEEB56Au,
+       0xC561B289u, 0x09CBB217u, 0xAC509190u, 0x60FA910Eu, 0xEE7596EDu,
+       0x22DF9673u, 0x281A9F6Au, 0xE4B09FF4u, 0x6A3F9817u, 0xA6959889u,
+       0x7FB58A25u, 0xB31F8ABBu, 0x3D908D58u, 0xF13A8DC6u, 0xFBFF84DFu,
+       0x37558441u, 0xB9DA83A2u, 0x7570833Cu, 0x533B85DAu, 0x9F918544u,
+       0x111E82A7u, 0xDDB48239u, 0xD7718B20u, 0x1BDB8BBEu, 0x95548C5Du,
+       0x59FE8CC3u, 0x80DE9E6Fu, 0x4C749EF1u, 0xC2FB9912u, 0x0E51998Cu,
+       0x04949095u, 0xC83E900Bu, 0x46B197E8u, 0x8A1B9776u, 0x2F80B4F1u,
+       0xE32AB46Fu, 0x6DA5B38Cu, 0xA10FB312u, 0xABCABA0Bu, 0x6760BA95u,
+       0xE9EFBD76u, 0x2545BDE8u, 0xFC65AF44u, 0x30CFAFDAu, 0xBE40A839u,
+       0x72EAA8A7u, 0x782FA1BEu, 0xB485A120u, 0x3A0AA6C3u, 0xF6A0A65Du,
+       0xAA4DE78Cu, 0x66E7E712u, 0xE868E0F1u, 0x24C2E06Fu, 0x2E07E976u,
+       0xE2ADE9E8u, 0x6C22EE0Bu, 0xA088EE95u, 0x79A8FC39u, 0xB502FCA7u,
+       0x3B8DFB44u, 0xF727FBDAu, 0xFDE2F2C3u, 0x3148F25Du, 0xBFC7F5BEu,
+       0x736DF520u, 0xD6F6D6A7u, 0x1A5CD639u, 0x94D3D1DAu, 0x5879D144u,
+       0x52BCD85Du, 0x9E16D8C3u, 0x1099DF20u, 0xDC33DFBEu, 0x0513CD12u,
+       0xC9B9CD8Cu, 0x4736CA6Fu, 0x8B9CCAF1u, 0x8159C3E8u, 0x4DF3C376u,
+       0xC37CC495u, 0x0FD6C40Bu, 0x7AA64737u, 0xB60C47A9u, 0x3883404Au,
+       0xF42940D4u, 0xFEEC49CDu, 0x32464953u, 0xBCC94EB0u, 0x70634E2Eu,
+       0xA9435C82u, 0x65E95C1Cu, 0xEB665BFFu, 0x27CC5B61u, 0x2D095278u,
+       0xE1A352E6u, 0x6F2C5505u, 0xA386559Bu, 0x061D761Cu, 0xCAB77682u,
+       0x44387161u, 0x889271FFu, 0x825778E6u, 0x4EFD7878u, 0xC0727F9Bu,
+       0x0CD87F05u, 0xD5F86DA9u, 0x19526D37u, 0x97DD6AD4u, 0x5B776A4Au,
+       0x51B26353u, 0x9D1863CDu, 0x1397642Eu, 0xDF3D64B0u, 0x83D02561u,
+       0x4F7A25FFu, 0xC1F5221Cu, 0x0D5F2282u, 0x079A2B9Bu, 0xCB302B05u,
+       0x45BF2CE6u, 0x89152C78u, 0x50353ED4u, 0x9C9F3E4Au, 0x121039A9u,
+       0xDEBA3937u, 0xD47F302Eu, 0x18D530B0u, 0x965A3753u, 0x5AF037CDu,
+       0xFF6B144Au, 0x33C114D4u, 0xBD4E1337u, 0x71E413A9u, 0x7B211AB0u,
+       0xB78B1A2Eu, 0x39041DCDu, 0xF5AE1D53u, 0x2C8E0FFFu, 0xE0240F61u,
+       0x6EAB0882u, 0xA201081Cu, 0xA8C40105u, 0x646E019Bu, 0xEAE10678u,
+       0x264B06E6u}}}};
 
-#ifdef SOURCEMETA_CORE_CRYPTO_CRC32_ARM
-  // ARMv8 hardware CRC32 instruction (~8 bytes per cycle)
-  while (remaining >= 8) {
-    std::uint64_t chunk{0};
-    std::memcpy(&chunk, data, sizeof(chunk));
-    checksum = crc32_hardware_word(checksum, chunk);
-    data += 8;
-    remaining -= 8;
-  }
-  while (remaining > 0) {
-    checksum = crc32_hardware_byte(checksum, *data++);
-    --remaining;
-  }
-  return checksum ^ 0xFFFFFFFFU;
-#else
-  // Slice-by-8 software fallback: consume 8 bytes per iteration
+auto crc32_software(std::uint32_t checksum, const std::uint8_t *data,
+                    std::size_t remaining) noexcept -> std::uint32_t {
+  // Slice-by-8: consume 8 bytes per iteration
   while (remaining >= 8) {
     const std::uint32_t one{(static_cast<std::uint32_t>(data[0])) |
                             (static_cast<std::uint32_t>(data[1]) << 8u) |
@@ -134,7 +589,274 @@ auto crc32_update(const std::uint32_t previous, const std::string_view input)
     --remaining;
   }
 
-  return checksum ^ 0xFFFFFFFFu;
+  return checksum;
+}
+
+} // namespace
+#endif
+
+#ifdef SOURCEMETA_CORE_CRYPTO_CRC32_FOLD
+namespace {
+
+#ifdef SOURCEMETA_CORE_CRYPTO_CRC32_PMULL
+using Crc32Vector = uint8x16_t;
+using Crc32Multipliers = poly64x2_t;
+
+auto crc32_vector_load(const std::uint8_t *data) noexcept -> Crc32Vector {
+  return vld1q_u8(data);
+}
+
+auto crc32_vector_xor(const Crc32Vector left, const Crc32Vector right) noexcept
+    -> Crc32Vector {
+  return veorq_u8(left, right);
+}
+
+auto crc32_vector_from_checksum(const std::uint32_t checksum) noexcept
+    -> Crc32Vector {
+  return vreinterpretq_u8_u32(vsetq_lane_u32(checksum, vdupq_n_u32(0), 0));
+}
+
+auto crc32_load_multipliers(
+    const std::array<std::uint64_t, 2> &multipliers) noexcept
+    -> Crc32Multipliers {
+  return vreinterpretq_p64_u64(vld1q_u64(multipliers.data()));
+}
+
+auto crc32_fold_vector(const Crc32Vector source, const Crc32Vector destination,
+                       const Crc32Multipliers multipliers) noexcept
+    -> Crc32Vector {
+  const Crc32Vector low{vreinterpretq_u8_p128(
+      vmull_p64(vgetq_lane_p64(vreinterpretq_p64_u8(source), 0),
+                vgetq_lane_p64(multipliers, 0)))};
+  const Crc32Vector high{vreinterpretq_u8_p128(
+      vmull_high_p64(vreinterpretq_p64_u8(source), multipliers))};
+  return veorq_u8(veorq_u8(low, high), destination);
+}
+
+// The folded vector is congruent to the data it replaces, so checksumming it
+// as data from an empty register yields the checksum of that data
+auto crc32_reduce(const Crc32Vector folded) noexcept -> std::uint32_t {
+  const uint64x2_t words{vreinterpretq_u64_u8(folded)};
+  return crc32_hardware_word(crc32_hardware_word(0, vgetq_lane_u64(words, 0)),
+                             vgetq_lane_u64(words, 1));
+}
+#else
+using Crc32Vector = __m128i;
+using Crc32Multipliers = __m128i;
+
+auto crc32_vector_load(const std::uint8_t *data) noexcept -> Crc32Vector {
+  return _mm_loadu_si128(reinterpret_cast<const __m128i *>(data));
+}
+
+auto crc32_vector_xor(const Crc32Vector left, const Crc32Vector right) noexcept
+    -> Crc32Vector {
+  return _mm_xor_si128(left, right);
+}
+
+auto crc32_vector_from_checksum(const std::uint32_t checksum) noexcept
+    -> Crc32Vector {
+  return _mm_cvtsi32_si128(static_cast<int>(checksum));
+}
+
+auto crc32_load_multipliers(
+    const std::array<std::uint64_t, 2> &multipliers) noexcept
+    -> Crc32Multipliers {
+  return _mm_loadu_si128(reinterpret_cast<const __m128i *>(multipliers.data()));
+}
+
+auto crc32_fold_vector(const Crc32Vector source, const Crc32Vector destination,
+                       const Crc32Multipliers multipliers) noexcept
+    -> Crc32Vector {
+  const Crc32Vector low{_mm_clmulepi64_si128(source, multipliers, 0x00)};
+  const Crc32Vector high{_mm_clmulepi64_si128(source, multipliers, 0x11)};
+  return _mm_xor_si128(_mm_xor_si128(low, high), destination);
+}
+
+// The folded vector is congruent to the data it replaces, so checksumming it
+// as data from an empty register yields the checksum of that data
+auto crc32_reduce(const Crc32Vector folded) noexcept -> std::uint32_t {
+  std::array<std::uint8_t, 16> bytes{};
+  _mm_storeu_si128(reinterpret_cast<__m128i *>(bytes.data()), folded);
+  return crc32_software(0, bytes.data(), bytes.size());
+}
+#endif
+
+// Moving a 128-bit vector forward by a number of 128-bit vectors multiplies
+// each of its halves by the remainder of a power of x modulo the CRC-32
+// polynomial, bit reflected like the checksum register. The powers are the
+// distance in bits plus 31 and minus 33, accounting for the width of each half
+// and for the product of two reflected values being one bit short
+constexpr std::array<std::uint64_t, 2> CRC32_FOLD_TWELVE{
+    {0x596C8D81U, 0xF5E48C85U}};
+constexpr std::array<std::uint64_t, 2> CRC32_FOLD_SIX{
+    {0xDF068DC2U, 0x57C54819U}};
+constexpr std::array<std::uint64_t, 2> CRC32_FOLD_FOUR{
+    {0x8F352D95U, 0x1D9513D7U}};
+constexpr std::array<std::uint64_t, 2> CRC32_FOLD_THREE{
+    {0x3DB1ECDCU, 0xAF449247U}};
+constexpr std::array<std::uint64_t, 2> CRC32_FOLD_TWO{
+    {0xF1DA05AAU, 0x81256527U}};
+constexpr std::array<std::uint64_t, 2> CRC32_FOLD_ONE{
+    {0xAE689191U, 0xCCAA009EU}};
+constexpr std::size_t CRC32_FOLD_MINIMUM{64};
+constexpr std::size_t CRC32_FOLD_WIDE_MINIMUM{576};
+
+// Folds whole 128-bit vectors of the input into a single vector congruent to
+// them modulo the CRC-32 polynomial, which is then reduced to a checksum.
+// Every lane is an independent dependency chain, so the multiplications of
+// all lanes run in parallel
+auto crc32_fold(const std::uint32_t checksum, const std::uint8_t *&data,
+                std::size_t &remaining) noexcept -> std::uint32_t {
+  // GCC drops the attributes of the x86 vector type when it is a template
+  // argument, so the lanes live in a plain array
+  // NOLINTNEXTLINE(modernize-avoid-c-arrays)
+  Crc32Vector lanes[12]{};
+  const Crc32Vector initial{crc32_vector_from_checksum(checksum)};
+  if (remaining >= CRC32_FOLD_WIDE_MINIMUM) {
+    const auto twelve{crc32_load_multipliers(CRC32_FOLD_TWELVE)};
+    const auto six{crc32_load_multipliers(CRC32_FOLD_SIX)};
+    const auto three{crc32_load_multipliers(CRC32_FOLD_THREE)};
+    for (std::size_t lane = 0; lane < 12; ++lane) {
+      lanes[lane] = crc32_vector_load(data + (16 * lane));
+    }
+
+    lanes[0] = crc32_vector_xor(lanes[0], initial);
+    data += 192;
+    remaining -= 192;
+    while (remaining >= 192) {
+      for (std::size_t lane = 0; lane < 12; ++lane) {
+        lanes[lane] = crc32_fold_vector(
+            lanes[lane], crc32_vector_load(data + (16 * lane)), twelve);
+      }
+
+      data += 192;
+      remaining -= 192;
+    }
+
+    for (std::size_t lane = 0; lane < 6; ++lane) {
+      lanes[lane] = crc32_fold_vector(lanes[lane], lanes[lane + 6], six);
+    }
+
+    if (remaining >= 96) {
+      for (std::size_t lane = 0; lane < 6; ++lane) {
+        lanes[lane] = crc32_fold_vector(
+            lanes[lane], crc32_vector_load(data + (16 * lane)), six);
+      }
+
+      data += 96;
+      remaining -= 96;
+    }
+
+    for (std::size_t lane = 0; lane < 3; ++lane) {
+      lanes[lane] = crc32_fold_vector(lanes[lane], lanes[lane + 3], three);
+    }
+
+    if (remaining >= 48) {
+      for (std::size_t lane = 0; lane < 3; ++lane) {
+        lanes[lane] = crc32_fold_vector(
+            lanes[lane], crc32_vector_load(data + (16 * lane)), three);
+      }
+
+      data += 48;
+      remaining -= 48;
+    }
+
+    const auto one{crc32_load_multipliers(CRC32_FOLD_ONE)};
+    lanes[0] = crc32_fold_vector(lanes[0], lanes[1], one);
+    lanes[0] = crc32_fold_vector(lanes[0], lanes[2], one);
+  } else {
+    const auto four{crc32_load_multipliers(CRC32_FOLD_FOUR)};
+    const auto two{crc32_load_multipliers(CRC32_FOLD_TWO)};
+    for (std::size_t lane = 0; lane < 4; ++lane) {
+      lanes[lane] = crc32_vector_load(data + (16 * lane));
+    }
+
+    lanes[0] = crc32_vector_xor(lanes[0], initial);
+    data += 64;
+    remaining -= 64;
+    while (remaining >= 64) {
+      for (std::size_t lane = 0; lane < 4; ++lane) {
+        lanes[lane] = crc32_fold_vector(
+            lanes[lane], crc32_vector_load(data + (16 * lane)), four);
+      }
+
+      data += 64;
+      remaining -= 64;
+    }
+
+    lanes[0] = crc32_fold_vector(lanes[0], lanes[2], two);
+    lanes[1] = crc32_fold_vector(lanes[1], lanes[3], two);
+    if (remaining >= 32) {
+      lanes[0] = crc32_fold_vector(lanes[0], crc32_vector_load(data), two);
+      lanes[1] = crc32_fold_vector(lanes[1], crc32_vector_load(data + 16), two);
+      data += 32;
+      remaining -= 32;
+    }
+
+    lanes[0] = crc32_fold_vector(lanes[0], lanes[1],
+                                 crc32_load_multipliers(CRC32_FOLD_ONE));
+  }
+
+  return crc32_reduce(lanes[0]);
+}
+
+} // namespace
+#endif
+
+namespace sourcemeta::core {
+
+auto crc32(const std::string_view input) -> std::uint32_t {
+  return crc32_update(0U, input);
+}
+
+auto crc32_update(const std::uint32_t previous, const std::string_view input)
+    -> std::uint32_t {
+  auto checksum{previous ^ 0xFFFFFFFFU};
+  const auto *data{reinterpret_cast<const std::uint8_t *>(input.data())};
+  auto remaining{input.size()};
+
+#ifdef SOURCEMETA_CORE_CRYPTO_CRC32_FOLD
+  // Carry-less multiplication folds a whole vector of input at a time
+  if (remaining >= CRC32_FOLD_MINIMUM) {
+    checksum = crc32_fold(checksum, data, remaining);
+  }
+#endif
+
+#ifdef SOURCEMETA_CORE_CRYPTO_CRC32_ARM
+#ifndef SOURCEMETA_CORE_CRYPTO_CRC32_PMULL
+  // ARMv8 hardware CRC32 instruction (~8 bytes per cycle)
+  while (remaining >= 3 * CRC32_CHUNK_SIZE) {
+    std::uint32_t first{checksum};
+    std::uint32_t second{0};
+    std::uint32_t third{0};
+    for (std::size_t offset = 0; offset < CRC32_CHUNK_SIZE; offset += 8) {
+      first = crc32_hardware_word(first, crc32_hardware_load(data + offset));
+      second = crc32_hardware_word(
+          second, crc32_hardware_load(data + CRC32_CHUNK_SIZE + offset));
+      third = crc32_hardware_word(
+          third, crc32_hardware_load(data + (2 * CRC32_CHUNK_SIZE) + offset));
+    }
+
+    checksum = crc32_shift_chunk(crc32_shift_chunk(first) ^ second) ^ third;
+    data += 3 * CRC32_CHUNK_SIZE;
+    remaining -= 3 * CRC32_CHUNK_SIZE;
+  }
+#endif
+
+  while (remaining >= 8) {
+    std::uint64_t chunk{0};
+    std::memcpy(&chunk, data, sizeof(chunk));
+    checksum = crc32_hardware_word(checksum, chunk);
+    data += 8;
+    remaining -= 8;
+  }
+  while (remaining > 0) {
+    checksum = crc32_hardware_byte(checksum, *data++);
+    --remaining;
+  }
+  return checksum ^ 0xFFFFFFFFU;
+#else
+  return crc32_software(checksum, data, remaining) ^ 0xFFFFFFFFU;
 #endif
 }
 
diff --git a/vendor/core/src/core/crypto/crypto_der.h b/vendor/core/src/core/crypto/crypto_der.h
index 2f2c240d..291c9449 100644
--- a/vendor/core/src/core/crypto/crypto_der.h
+++ b/vendor/core/src/core/crypto/crypto_der.h
@@ -8,7 +8,6 @@
 #include <optional>    // std::optional, std::nullopt
 #include <string>      // std::string
 #include <string_view> // std::string_view
-#include <utility>     // std::pair
 
 namespace sourcemeta::core {
 
@@ -146,39 +145,6 @@ inline auto der_unsigned_integer(std::string_view content)
   return content;
 }
 
-// Read the modulus and public exponent from a PKCS#1 RSAPublicKey structure
-// (RFC 8017 Appendix A.1.1), a DER SEQUENCE of exactly the two integers, each
-// returned as its minimal big-endian magnitude. Trailing bytes at either level
-// are rejected so the input parses as exactly that structure
-inline auto der_read_rsa_public_key(const std::string_view der)
-    -> std::optional<std::pair<std::string, std::string>> {
-  const auto sequence{der_read(der)};
-  if (!sequence.has_value() || sequence->tag != 0x30 ||
-      !sequence->rest.empty()) {
-    return std::nullopt;
-  }
-
-  const auto modulus{der_read(sequence->content)};
-  if (!modulus.has_value() || modulus->tag != 0x02) {
-    return std::nullopt;
-  }
-
-  const auto exponent{der_read(modulus->rest)};
-  if (!exponent.has_value() || exponent->tag != 0x02 ||
-      !exponent->rest.empty()) {
-    return std::nullopt;
-  }
-
-  const auto modulus_value{der_unsigned_integer(modulus->content)};
-  const auto exponent_value{der_unsigned_integer(exponent->content)};
-  if (!modulus_value.has_value() || !exponent_value.has_value()) {
-    return std::nullopt;
-  }
-
-  return std::pair{std::string{modulus_value.value()},
-                   std::string{exponent_value.value()}};
-}
-
 } // namespace sourcemeta::core
 
 #endif
diff --git a/vendor/core/src/core/crypto/crypto_ecc.h b/vendor/core/src/core/crypto/crypto_ecc.h
index ea361c59..a9df1055 100644
--- a/vendor/core/src/core/crypto/crypto_ecc.h
+++ b/vendor/core/src/core/crypto/crypto_ecc.h
@@ -23,12 +23,12 @@ namespace sourcemeta::core {
 enum class NISTPrime : std::uint8_t { P256, P384, P521 };
 
 struct EllipticCurveParameters {
-  Bignum prime;
-  Bignum coefficient_a;
-  Bignum coefficient_b;
-  Bignum generator_x;
-  Bignum generator_y;
-  Bignum order;
+  CurveBignum prime;
+  CurveBignum coefficient_a;
+  CurveBignum coefficient_b;
+  CurveBignum generator_x;
+  CurveBignum generator_y;
+  CurveBignum order;
   std::size_t field_bytes;
   NISTPrime reduction;
 };
@@ -36,31 +36,31 @@ struct EllipticCurveParameters {
 // A point in Jacobian coordinates, where the affine point is
 // (X / Z^2, Y / Z^3). A zero Z marks the point at infinity
 struct JacobianPoint {
-  Bignum x;
-  Bignum y;
-  Bignum z;
+  CurveBignum x;
+  CurveBignum y;
+  CurveBignum z;
 };
 
 // FIPS 186-4 Appendix D.1.2 curve domain parameters
 inline auto curve_p256() -> EllipticCurveParameters {
-  return {.prime =
-              bignum_from_hex("ffffffff00000001000000000000000000000000ffffffff"
-                              "ffffffffffffffff"),
-          .coefficient_a =
-              bignum_from_hex("ffffffff00000001000000000000000000000000ffffffff"
-                              "fffffffffffffffc"),
-          .coefficient_b =
-              bignum_from_hex("5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f6"
-                              "3bce3c3e27d2604b"),
-          .generator_x =
-              bignum_from_hex("6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0"
-                              "f4a13945d898c296"),
-          .generator_y =
-              bignum_from_hex("4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ece"
-                              "cbb6406837bf51f5"),
-          .order =
-              bignum_from_hex("ffffffff00000000ffffffffffffffffbce6faada7179e84"
-                              "f3b9cac2fc632551"),
+  return {.prime = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
+              "ffffffff00000001000000000000000000000000ffffffff"
+              "ffffffffffffffff"),
+          .coefficient_a = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
+              "ffffffff00000001000000000000000000000000ffffffff"
+              "fffffffffffffffc"),
+          .coefficient_b = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
+              "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f6"
+              "3bce3c3e27d2604b"),
+          .generator_x = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
+              "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0"
+              "f4a13945d898c296"),
+          .generator_y = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
+              "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ece"
+              "cbb6406837bf51f5"),
+          .order = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
+              "ffffffff00000000ffffffffffffffffbce6faada7179e84"
+              "f3b9cac2fc632551"),
           .field_bytes = 32,
           .reduction = NISTPrime::P256};
 }
@@ -70,12 +70,12 @@ inline auto curve_p384() -> EllipticCurveParameters {
   // is ever lost across a line break
   // clang-format off
   return {
-      .prime = bignum_from_hex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff"),
-      .coefficient_a = bignum_from_hex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffc"),
-      .coefficient_b = bignum_from_hex("b3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef"),
-      .generator_x = bignum_from_hex("aa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7"),
-      .generator_y = bignum_from_hex("3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f"),
-      .order = bignum_from_hex("ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973"),
+      .prime = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff"),
+      .coefficient_a = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffc"),
+      .coefficient_b = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("b3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef"),
+      .generator_x = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("aa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7"),
+      .generator_y = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f"),
+      .order = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973"),
       .field_bytes = 48,
       .reduction = NISTPrime::P384};
   // clang-format on
@@ -84,12 +84,12 @@ inline auto curve_p384() -> EllipticCurveParameters {
 inline auto curve_p521() -> EllipticCurveParameters {
   // clang-format off
   return {
-      .prime = bignum_from_hex("01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
-      .coefficient_a = bignum_from_hex("01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc"),
-      .coefficient_b = bignum_from_hex("0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00"),
-      .generator_x = bignum_from_hex("00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66"),
-      .generator_y = bignum_from_hex("011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650"),
-      .order = bignum_from_hex("01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409"),
+      .prime = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+      .coefficient_a = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc"),
+      .coefficient_b = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00"),
+      .generator_x = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66"),
+      .generator_y = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650"),
+      .order = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409"),
       .field_bytes = 66,
       .reduction = NISTPrime::P521};
   // clang-format on
@@ -98,8 +98,8 @@ inline auto curve_p521() -> EllipticCurveParameters {
 // NIST P-521 field reduction. The prime is 2^521 - 1, so 2^521 is congruent
 // to 1 modulo it, and a value below the square of the prime folds the bits
 // above position 521 back into the low 521 bits with a single addition
-inline auto field_reduce_p521(Bignum &value, const Bignum &prime) noexcept
-    -> void {
+inline auto field_reduce_p521(CurveBignum &value,
+                              const CurveBignum &prime) noexcept -> void {
   auto high{bignum_shift_right(value, 521)};
   if (value.size > 8) {
     value.words[8] &= 0x1ffULL;
@@ -119,8 +119,8 @@ inline auto field_reduce_p521(Bignum &value, const Bignum &prime) noexcept
 
 // Read the 32-bit limb at the given position, counting from the least
 // significant, returning zero past the end of the value
-inline auto field_word(const Bignum &value, const std::size_t index) noexcept
-    -> std::uint64_t {
+inline auto field_word(const CurveBignum &value,
+                       const std::size_t index) noexcept -> std::uint64_t {
   const auto word{index / 2};
   if (word >= value.size) {
     return 0;
@@ -137,20 +137,24 @@ template <std::size_t Count>
 inline auto field_accumulate(std::array<std::uint64_t, Count + 1> &columns,
                              const std::array<std::uint64_t, Count> &limbs,
                              const std::uint64_t multiplier) noexcept -> void {
+  auto *columns_data{columns.data()};
+  const auto *limbs_data{limbs.data()};
   for (std::size_t index = 0; index < Count; ++index) {
-    columns[Count - 1 - index] += multiplier * limbs[index];
+    columns_data[Count - 1 - index] += multiplier * limbs_data[index];
   }
 }
 
 // Carry propagate the 32-bit columns and pack them into a value
 template <std::size_t Count>
 inline auto field_from_columns(std::array<std::uint64_t, Count + 1> &columns)
-    -> Bignum {
+    -> CurveBignum {
   std::uint64_t carry{0};
-  Bignum result;
+  CurveBignum result;
+  const auto *columns_data{columns.data()};
+  auto *result_data{result.words.data()};
   for (std::size_t index = 0; index <= Count; ++index) {
-    const auto current{columns[index] + carry};
-    result.words[index / 2] |= (current & 0xffffffffULL) << (32 * (index % 2));
+    const auto current{columns_data[index] + carry};
+    result_data[index / 2] |= (current & 0xffffffffULL) << (32 * (index % 2));
     carry = current >> 32;
   }
 
@@ -161,8 +165,8 @@ inline auto field_from_columns(std::array<std::uint64_t, Count + 1> &columns)
 
 // Combine the positive and negative column sums of a generalized Mersenne
 // reduction into the single reduced value below the prime
-inline auto field_combine(Bignum &positive, const Bignum &negative,
-                          const Bignum &prime) noexcept -> void {
+inline auto field_combine(CurveBignum &positive, const CurveBignum &negative,
+                          const CurveBignum &prime) noexcept -> void {
   while (bignum_compare(positive, negative) < 0) {
     positive = bignum_add(positive, prime);
   }
@@ -177,9 +181,10 @@ inline auto field_combine(Bignum &positive, const Bignum &negative,
 // a generalized Mersenne prime whose reduction recombines the 32-bit limbs of
 // the product into a small signed sum of nine field-width terms
 // (FIPS 186-4 Appendix D.2.3)
-inline auto field_reduce_p256(Bignum &value, const Bignum &prime) noexcept
-    -> void {
-  std::array<std::uint64_t, 16> c{};
+inline auto field_reduce_p256(CurveBignum &value,
+                              const CurveBignum &prime) noexcept -> void {
+  std::array<std::uint64_t, 16> limbs{};
+  auto *c{limbs.data()};
   for (std::size_t index = 0; index < 16; ++index) {
     c[index] = field_word(value, index);
   }
@@ -216,9 +221,10 @@ inline auto field_reduce_p256(Bignum &value, const Bignum &prime) noexcept
 // a generalized Mersenne prime whose reduction recombines the 32-bit limbs of
 // the product into a small signed sum of ten field-width terms
 // (FIPS 186-4 Appendix D.2.4)
-inline auto field_reduce_p384(Bignum &value, const Bignum &prime) noexcept
-    -> void {
-  std::array<std::uint64_t, 24> c{};
+inline auto field_reduce_p384(CurveBignum &value,
+                              const CurveBignum &prime) noexcept -> void {
+  std::array<std::uint64_t, 24> limbs{};
+  auto *c{limbs.data()};
   for (std::size_t index = 0; index < 24; ++index) {
     c[index] = field_word(value, index);
   }
@@ -267,7 +273,7 @@ inline auto field_reduce_p384(Bignum &value, const Bignum &prime) noexcept
 
 // Reduce a product below the square of the field prime, taking the fast
 // generalized Mersenne path for the curve rather than long division
-inline auto field_reduce(Bignum &value,
+inline auto field_reduce(CurveBignum &value,
                          const EllipticCurveParameters &curve) noexcept
     -> void {
   switch (curve.reduction) {
@@ -283,18 +289,22 @@ inline auto field_reduce(Bignum &value,
   }
 }
 
-inline auto field_mod_multiply(const Bignum &left, const Bignum &right,
+inline auto field_mod_multiply(const CurveBignum &left,
+                               const CurveBignum &right,
                                const EllipticCurveParameters &curve) noexcept
-    -> Bignum {
+    -> CurveBignum {
   auto result{bignum_multiply(left, right)};
   field_reduce(result, curve);
   return result;
 }
 
-inline auto field_square(const Bignum &value,
+inline auto field_square(const CurveBignum &value,
                          const EllipticCurveParameters &curve) noexcept
-    -> Bignum {
-  return field_mod_multiply(value, value, curve);
+    -> CurveBignum {
+  auto result{bignum_square_fixed(value, value.size)};
+  bignum_normalize(result);
+  field_reduce(result, curve);
+  return result;
 }
 
 inline auto point_is_infinity(const JacobianPoint &point) noexcept -> bool {
@@ -382,7 +392,9 @@ inline auto point_add(const JacobianPoint &left, const JacobianPoint &right,
   const auto u1_h_squared{field_mod_multiply(u1, h_squared, curve)};
   const auto result_x{bignum_mod_subtract(
       bignum_mod_subtract(field_square(r, curve), h_cubed, prime),
-      field_mod_multiply(bignum_from_u64(2), u1_h_squared, curve), prime)};
+      field_mod_multiply(bignum_from_u64<CURVE_BIGNUM_CAPACITY>(2),
+                         u1_h_squared, curve),
+      prime)};
   const auto result_y{bignum_mod_subtract(
       field_mod_multiply(r, bignum_mod_subtract(u1_h_squared, result_x, prime),
                          curve),
@@ -462,7 +474,7 @@ inline auto point_to_affine(const JacobianPoint &point,
       field_mod_multiply(z_inverse_squared, z_inverse, curve)};
   return {.x = field_mod_multiply(point.x, z_inverse_squared, curve),
           .y = field_mod_multiply(point.y, z_inverse_cubed, curve),
-          .z = bignum_from_u64(1)};
+          .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
 }
 
 // Compute scalar_one * point_one + scalar_two * point_two with Shamir's trick,
@@ -470,9 +482,9 @@ inline auto point_to_affine(const JacobianPoint &point,
 // whenever both scalars have a set bit, halving the doublings of two separate
 // scalar multiplications. The three addable points are kept affine so every
 // step takes the mixed addition
-inline auto point_double_scalar_multiply(const Bignum &scalar_one,
+inline auto point_double_scalar_multiply(const CurveBignum &scalar_one,
                                          const JacobianPoint &point_one,
-                                         const Bignum &scalar_two,
+                                         const CurveBignum &scalar_two,
                                          const JacobianPoint &point_two,
                                          const EllipticCurveParameters &curve)
     -> JacobianPoint {
@@ -500,7 +512,8 @@ inline auto point_double_scalar_multiply(const Bignum &scalar_one,
 
 // Recover the affine x coordinate (X / Z^2) of a Jacobian point
 inline auto point_affine_x(const JacobianPoint &point,
-                           const EllipticCurveParameters &curve) -> Bignum {
+                           const EllipticCurveParameters &curve)
+    -> CurveBignum {
   const auto z_inverse{bignum_mod_inverse(point.z, curve.prime)};
   const auto z_inverse_squared{field_square(z_inverse, curve)};
   return field_mod_multiply(point.x, z_inverse_squared, curve);
@@ -508,11 +521,15 @@ inline auto point_affine_x(const JacobianPoint &point,
 
 inline auto point_conditional_select(const bool condition,
                                      const JacobianPoint &when_true,
-                                     const JacobianPoint &when_false) noexcept
+                                     const JacobianPoint &when_false,
+                                     const std::size_t words) noexcept
     -> JacobianPoint {
-  return {.x = bignum_conditional_select(condition, when_true.x, when_false.x),
-          .y = bignum_conditional_select(condition, when_true.y, when_false.y),
-          .z = bignum_conditional_select(condition, when_true.z, when_false.z)};
+  return {.x = bignum_conditional_select(condition, when_true.x, when_false.x,
+                                         words),
+          .y = bignum_conditional_select(condition, when_true.y, when_false.y,
+                                         words),
+          .z = bignum_conditional_select(condition, when_true.z, when_false.z,
+                                         words)};
 }
 
 // Complete projective point addition for the prime-order NIST curves, whose
@@ -522,8 +539,8 @@ inline auto point_conditional_select(const bool condition,
 // ladder steps. Coordinates here are projective, so the affine point is X / Z
 inline auto point_complete_add(const JacobianPoint &left,
                                const JacobianPoint &right,
-                               const Bignum &coefficient_b,
-                               const BarrettContext &field) noexcept
+                               const CurveBignum &coefficient_b,
+                               const CurveBarrettContext &field) noexcept
     -> JacobianPoint {
   auto t0{field_mod_multiply_ct(left.x, right.x, field)};
   auto t1{field_mod_multiply_ct(left.y, right.y, field)};
@@ -571,31 +588,203 @@ inline auto point_complete_add(const JacobianPoint &left,
   return {.x = x3, .y = y3, .z = z3};
 }
 
-// For the signing path, where the scalar is the secret nonce: a fixed-length
-// double-and-add-always ladder over the complete formula with a masked
-// selection, so neither the per-bit branch nor the field arithmetic underneath
-// depends on the scalar. The input point and the result are projective
+// Exception-free projective point doubling for the same curves (Renes,
+// Costello, and Batina 2016, Algorithm 6). It agrees with the complete addition
+// of a point to itself, the identity included, for four fewer multiplications,
+// three of the rest being squarings
+inline auto point_complete_double(const JacobianPoint &point,
+                                  const CurveBignum &coefficient_b,
+                                  const CurveBarrettContext &field) noexcept
+    -> JacobianPoint {
+  auto t0{field_square_ct(point.x, field)};
+  const auto t1{field_square_ct(point.y, field)};
+  auto t2{field_square_ct(point.z, field)};
+  auto t3{field_mod_multiply_ct(point.x, point.y, field)};
+  t3 = field_add_ct(t3, t3, field);
+  auto z3{field_mod_multiply_ct(point.x, point.z, field)};
+  z3 = field_add_ct(z3, z3, field);
+  auto y3{field_mod_multiply_ct(coefficient_b, t2, field)};
+  y3 = field_subtract_ct(y3, z3, field);
+  auto x3{field_add_ct(y3, y3, field)};
+  y3 = field_add_ct(x3, y3, field);
+  x3 = field_subtract_ct(t1, y3, field);
+  y3 = field_add_ct(t1, y3, field);
+  y3 = field_mod_multiply_ct(x3, y3, field);
+  x3 = field_mod_multiply_ct(x3, t3, field);
+  t3 = field_add_ct(t2, t2, field);
+  t2 = field_add_ct(t2, t3, field);
+  z3 = field_mod_multiply_ct(coefficient_b, z3, field);
+  z3 = field_subtract_ct(z3, t2, field);
+  z3 = field_subtract_ct(z3, t0, field);
+  t3 = field_add_ct(z3, z3, field);
+  z3 = field_add_ct(z3, t3, field);
+  t3 = field_add_ct(t0, t0, field);
+  t0 = field_add_ct(t3, t0, field);
+  t0 = field_subtract_ct(t0, t2, field);
+  t0 = field_mod_multiply_ct(t0, z3, field);
+  y3 = field_add_ct(y3, t0, field);
+  t0 = field_mod_multiply_ct(point.y, point.z, field);
+  t0 = field_add_ct(t0, t0, field);
+  z3 = field_mod_multiply_ct(t0, z3, field);
+  x3 = field_subtract_ct(x3, z3, field);
+  z3 = field_mod_multiply_ct(t0, t1, field);
+  z3 = field_add_ct(z3, z3, field);
+  z3 = field_add_ct(z3, z3, field);
+  return {.x = x3, .y = y3, .z = z3};
+}
+
+// NIST P-521 field reduction in constant time, for the signing ladder. The
+// prime is 2^521 - 1, so the bits of a product above position 521 fold back
+// onto the low 521 bits with one fixed-width addition, and folding the bit 521
+// of that sum once more leaves a value no greater than 2^521. Such a value is
+// at least the prime exactly when adding one to it reaches bit 521, and that
+// sum without bit 521 is then the reduced value, so a single masked selection
+// finishes the reduction
+inline auto field_reduce_p521_ct(
+    const CurveBignum &value,
+    [[maybe_unused]] const CurveBarrettContext &context) noexcept
+    -> CurveBignum {
+  const auto *value_data{value.words.data()};
+  CurveBignum sum;
+  auto *sum_data{sum.words.data()};
+  std::uint64_t carry{0};
+  for (std::size_t index = 0; index < 8; ++index) {
+    const auto high{(value_data[index + 8] >> 9U) |
+                    (value_data[index + 9] << 55U)};
+    const auto total{static_cast<BignumDoubleWord>(value_data[index]) + high +
+                     carry};
+    sum_data[index] = static_cast<std::uint64_t>(total);
+    carry = static_cast<std::uint64_t>(total >> 64U);
+  }
+
+  // The top word keeps only the nine bits below position 521, and the product
+  // bits folded onto it stay below 2^9, so its sum cannot overflow
+  sum_data[8] = (value_data[8] & 0x1ffULL) +
+                ((value_data[16] >> 9U) | (value_data[17] << 55U)) + carry;
+
+  std::uint64_t addend{sum_data[8] >> 9U};
+  sum_data[8] &= 0x1ffULL;
+  for (std::size_t index = 0; index < 9; ++index) {
+    const auto total{static_cast<BignumDoubleWord>(sum_data[index]) + addend};
+    sum_data[index] = static_cast<std::uint64_t>(total);
+    addend = static_cast<std::uint64_t>(total >> 64U);
+  }
+
+  CurveBignum reduced;
+  auto *reduced_data{reduced.words.data()};
+  addend = 1;
+  for (std::size_t index = 0; index < 9; ++index) {
+    const auto total{static_cast<BignumDoubleWord>(sum_data[index]) + addend};
+    reduced_data[index] = static_cast<std::uint64_t>(total);
+    addend = static_cast<std::uint64_t>(total >> 64U);
+  }
+
+  const auto at_least_prime{(reduced_data[8] >> 9U) != 0};
+  reduced_data[8] &= 0x1ffULL;
+  sum.size = 9;
+  reduced.size = 9;
+  return bignum_conditional_select(at_least_prime, reduced, sum, 9);
+}
+
+// The constant-time field arithmetic context of a curve, taking the Mersenne
+// reduction for P-521 over the generic Barrett one
+inline auto curve_field_context(const EllipticCurveParameters &curve)
+    -> CurveBarrettContext {
+  auto field{barrett_context(curve.prime)};
+  if (curve.reduction == NISTPrime::P521) {
+    field.reduce = &field_reduce_p521_ct;
+  }
+
+  return field;
+}
+
+// The field arithmetic context of the signing ladder, taking the Mersenne
+// reduction for P-521 and Montgomery form for the other curves, whose
+// reduction is cheaper than the Barrett one
+inline auto curve_ladder_context(const EllipticCurveParameters &curve)
+    -> CurveBarrettContext {
+  const auto field{curve_field_context(curve)};
+  if (curve.reduction == NISTPrime::P521) {
+    return field;
+  }
+
+  return montgomery_context(field);
+}
+
+// Move the coordinates of a projective point into the representation of a
+// context, and back out of it
+inline auto point_to_montgomery(const JacobianPoint &point,
+                                const CurveBarrettContext &field) noexcept
+    -> JacobianPoint {
+  return {.x = field_to_montgomery_ct(point.x, field),
+          .y = field_to_montgomery_ct(point.y, field),
+          .z = field_to_montgomery_ct(point.z, field)};
+}
+
+inline auto point_from_montgomery(const JacobianPoint &point,
+                                  const CurveBarrettContext &field) noexcept
+    -> JacobianPoint {
+  return {.x = field_from_montgomery_ct(point.x, field),
+          .y = field_from_montgomery_ct(point.y, field),
+          .z = field_from_montgomery_ct(point.z, field)};
+}
+
+// For the signing path, where the scalar is the secret nonce: a fixed four-bit
+// window ladder over the complete formula. The window count is fixed by the
+// public order length, every window doubles four times and adds one table entry
+// taken through a masked scan over the whole table, and the complete formula
+// absorbs the identity entry of a zero window, so neither the control flow nor
+// the field arithmetic underneath depends on the scalar. The arithmetic runs in
+// the representation of the ladder context, and the input point and the result
+// are projective outside of it
 inline auto point_scalar_multiply_constant_time(
-    const Bignum &scalar, const JacobianPoint &point,
+    const CurveBignum &scalar, const JacobianPoint &point,
     const EllipticCurveParameters &curve) -> JacobianPoint {
-  const auto field{barrett_context(curve.prime)};
-  JacobianPoint result{.x = Bignum{}, .y = bignum_from_u64(1), .z = Bignum{}};
-  const auto scalar_bits{bignum_bit_length(curve.order)};
-  for (std::size_t index = scalar_bits; index > 0; --index) {
-    result = point_complete_add(result, result, curve.coefficient_b, field);
-    const auto sum{
-        point_complete_add(result, point, curve.coefficient_b, field)};
-    result = point_conditional_select(bignum_get_bit_fixed(scalar, index - 1),
-                                      sum, result);
+  const auto field{curve_ladder_context(curve)};
+  const auto coefficient_b{field_to_montgomery_ct(curve.coefficient_b, field)};
+  const auto base_point{point_to_montgomery(point, field)};
+  std::array<JacobianPoint, 16> multiples{};
+  multiples[0] =
+      JacobianPoint{.x = CurveBignum{},
+                    .y = field_to_montgomery_ct(
+                        bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1), field),
+                    .z = CurveBignum{}};
+  multiples[1] = base_point;
+  for (std::size_t index = 2; index < multiples.size(); ++index) {
+    multiples[index] = point_complete_add(multiples[index - 1], base_point,
+                                          coefficient_b, field);
   }
 
-  return result;
+  auto result{multiples[0]};
+  const auto windows{(bignum_bit_length(curve.order) + 3) / 4};
+  for (std::size_t window = windows; window > 0; --window) {
+    for (std::size_t step = 0; step < 4; ++step) {
+      result = point_complete_double(result, coefficient_b, field);
+    }
+
+    std::size_t digit{0};
+    for (std::size_t bit = 0; bit < 4; ++bit) {
+      digit |= static_cast<std::size_t>(
+                   bignum_get_bit_fixed(scalar, ((window - 1) * 4) + bit))
+               << bit;
+    }
+
+    JacobianPoint selected{};
+    for (std::size_t index = 0; index < multiples.size(); ++index) {
+      selected = point_conditional_select(digit == index, multiples[index],
+                                          selected, field.words);
+    }
+
+    result = point_complete_add(result, selected, coefficient_b, field);
+  }
+
+  return point_from_montgomery(result, field);
 }
 
 inline auto point_affine_x_constant_time(const JacobianPoint &point,
                                          const EllipticCurveParameters &curve)
-    -> Bignum {
-  const auto field{barrett_context(curve.prime)};
+    -> CurveBignum {
+  const auto field{curve_field_context(curve)};
   const auto z_inverse{field_inverse_ct(point.z, field)};
   auto result{field_mod_multiply_ct(point.x, z_inverse, field)};
   bignum_normalize(result);
@@ -603,7 +792,7 @@ inline auto point_affine_x_constant_time(const JacobianPoint &point,
 }
 
 // Whether the affine point satisfies y^2 = x^3 + a*x + b (mod p)
-inline auto point_on_curve(const Bignum &x, const Bignum &y,
+inline auto point_on_curve(const CurveBignum &x, const CurveBignum &y,
                            const EllipticCurveParameters &curve) -> bool {
   const auto &prime{curve.prime};
   const auto left{field_square(y, curve)};
diff --git a/vendor/core/src/core/crypto/crypto_ecdh_other.cc b/vendor/core/src/core/crypto/crypto_ecdh_other.cc
index 34a153c0..f6f17c93 100644
--- a/vendor/core/src/core/crypto/crypto_ecdh_other.cc
+++ b/vendor/core/src/core/crypto/crypto_ecdh_other.cc
@@ -42,8 +42,10 @@ auto ecdh_derive(const PrivateKey &private_key, const PublicKey &public_key)
   }
 
   const auto parameters{to_curve_parameters(private_internal->elliptic_curve)};
-  const auto peer_x{bignum_from_bytes(public_internal->coordinate_x)};
-  const auto peer_y{bignum_from_bytes(public_internal->coordinate_y)};
+  const auto peer_x{
+      bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(public_internal->coordinate_x)};
+  const auto peer_y{
+      bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(public_internal->coordinate_y)};
   // Invalid-curve defense: the peer coordinates must be below the field prime
   // and satisfy the curve equation
   if (bignum_compare(peer_x, parameters.prime) >= 0 ||
@@ -53,8 +55,9 @@ auto ecdh_derive(const PrivateKey &private_key, const PublicKey &public_key)
   }
 
   const JacobianPoint peer_point{
-      .x = peer_x, .y = peer_y, .z = bignum_from_u64(1)};
-  auto scalar{bignum_from_bytes(private_internal->scalar)};
+      .x = peer_x, .y = peer_y, .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
+  auto scalar{
+      bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(private_internal->scalar)};
   const SecureBignumScope scalar_scope{scalar};
   const auto product{
       point_scalar_multiply_constant_time(scalar, peer_point, parameters)};
diff --git a/vendor/core/src/core/crypto/crypto_eddsa.h b/vendor/core/src/core/crypto/crypto_eddsa.h
index 1640a4de..84bd1ace 100644
--- a/vendor/core/src/core/crypto/crypto_eddsa.h
+++ b/vendor/core/src/core/crypto/crypto_eddsa.h
@@ -15,6 +15,7 @@
 #include "crypto_helpers.h"
 #include "crypto_shake256.h"
 
+#include <array>       // std::array
 #include <cstddef>     // std::size_t
 #include <cstdint>     // std::uint8_t
 #include <optional>    // std::optional, std::nullopt
@@ -26,94 +27,119 @@ namespace sourcemeta::core {
 // A point in extended Edwards coordinates (X : Y : Z : T), where the affine
 // point is (X / Z, Y / Z) and T = X * Y / Z (RFC 8032 Section 5.1.4)
 struct EdwardsPoint {
-  Bignum x;
-  Bignum y;
-  Bignum z;
-  Bignum t;
+  CurveBignum x;
+  CurveBignum y;
+  CurveBignum z;
+  CurveBignum t;
 };
 
 struct EdwardsParameters {
-  Bignum prime;
-  Bignum order;
-  Bignum coefficient_a;
-  Bignum coefficient_d;
+  CurveBignum prime;
+  CurveBignum order;
+  CurveBignum coefficient_a;
+  CurveBignum coefficient_d;
+  // Whether the coefficient a is -1, as on the twisted Ed25519 curve, rather
+  // than 1, as on Ed448, which lets the point formulas negate or keep a value
+  // instead of multiplying it by the coefficient
+  bool coefficient_a_is_minus_one{false};
+  // A square root of -1 modulo the Ed25519 prime, which recovers the second
+  // candidate root when decoding a point, and left zero for Ed448
+  CurveBignum square_root_of_minus_one;
   EdwardsPoint base;
+  // The constant-time field and group order arithmetic contexts, built with the
+  // parameters so that every ladder and signature does not rebuild them
+  CurveBarrettContext field;
+  CurveBarrettContext order_field;
 };
 
 // Interpret the bytes as a little-endian unsigned integer, the encoding EdDSA
 // uses throughout (RFC 8032 Section 5.1.2), by reversing into the big-endian
 // conversion
 inline auto bignum_from_bytes_little_endian(const std::string_view input)
-    -> Bignum {
+    -> CurveBignum {
   const std::string reversed{input.rbegin(), input.rend()};
-  return bignum_from_bytes(reversed);
+  return bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(reversed);
 }
 
-// The complete unified Edwards addition formulas in extended coordinates
-// (Hisil, Wong, Carter, and Dawson 2008), which hold for any two points,
-// including equal points and the identity, since the curve coefficient is a
-// square and d is a non-square modulo p
-inline auto edwards_point_add(const EdwardsPoint &left,
-                              const EdwardsPoint &right,
-                              const EdwardsParameters &parameters)
-    -> EdwardsPoint {
-  const auto &prime{parameters.prime};
-  const auto a{bignum_mod_multiply(left.x, right.x, prime)};
-  const auto b{bignum_mod_multiply(left.y, right.y, prime)};
-  const auto c{bignum_mod_multiply(
-      bignum_mod_multiply(parameters.coefficient_d, left.t, prime), right.t,
-      prime)};
-  const auto d{bignum_mod_multiply(left.z, right.z, prime)};
-  const auto e{bignum_mod_subtract(
-      bignum_mod_multiply(bignum_mod_add(left.x, left.y, prime),
-                          bignum_mod_add(right.x, right.y, prime), prime),
-      bignum_mod_add(a, b, prime), prime)};
-  const auto f{bignum_mod_subtract(d, c, prime)};
-  const auto g{bignum_mod_add(d, c, prime)};
-  const auto h{bignum_mod_subtract(
-      b, bignum_mod_multiply(parameters.coefficient_a, a, prime), prime)};
-  return EdwardsPoint{.x = bignum_mod_multiply(e, f, prime),
-                      .y = bignum_mod_multiply(g, h, prime),
-                      .z = bignum_mod_multiply(f, g, prime),
-                      .t = bignum_mod_multiply(e, h, prime)};
-}
+// Ed25519 field reduction in constant time, for the signing ladder. The prime
+// is 2^255 - 19, so 2^256 is congruent to 38 modulo it, and the high half of a
+// product folds onto the low half scaled by 38, carrying at most 38 out of the
+// top word. A second fold takes that carry, worth 38 each, and bit 255, worth
+// 19, back in at once, leaving a value below 2^255 + 1463. Such a value is at
+// least the prime exactly when adding 19 to it reaches bit 255, and that sum
+// without bit 255 is then the reduced value, so a single masked selection
+// finishes the reduction
+inline auto field_reduce_25519_ct(
+    const CurveBignum &value,
+    [[maybe_unused]] const CurveBarrettContext &context) noexcept
+    -> CurveBignum {
+  const auto *value_data{value.words.data()};
+  CurveBignum folded;
+  auto *folded_data{folded.words.data()};
+  std::uint64_t carry{0};
+  for (std::size_t index = 0; index < 4; ++index) {
+    const auto total{
+        static_cast<BignumDoubleWord>(value_data[index]) +
+        (static_cast<BignumDoubleWord>(value_data[index + 4]) * 38U) + carry};
+    folded_data[index] = static_cast<std::uint64_t>(total);
+    carry = static_cast<std::uint64_t>(total >> 64U);
+  }
 
-inline auto edwards_point_scalar_multiply(const Bignum &scalar,
-                                          const EdwardsPoint &point,
-                                          const EdwardsParameters &parameters)
-    -> EdwardsPoint {
-  // The identity element is (0 : 1 : 1 : 0)
-  EdwardsPoint result{.x = Bignum{},
-                      .y = bignum_from_u64(1),
-                      .z = bignum_from_u64(1),
-                      .t = Bignum{}};
-  const auto bits{bignum_bit_length(scalar)};
-  for (std::size_t index = bits; index > 0; --index) {
-    result = edwards_point_add(result, result, parameters);
-    if (bignum_get_bit(scalar, index - 1)) {
-      result = edwards_point_add(result, point, parameters);
-    }
+  std::uint64_t addend{((folded_data[3] >> 63U) + (carry << 1U)) * 19U};
+  folded_data[3] &= 0x7fffffffffffffffULL;
+  for (std::size_t index = 0; index < 4; ++index) {
+    const auto total{static_cast<BignumDoubleWord>(folded_data[index]) +
+                     addend};
+    folded_data[index] = static_cast<std::uint64_t>(total);
+    addend = static_cast<std::uint64_t>(total >> 64U);
   }
 
-  return result;
+  CurveBignum reduced;
+  auto *reduced_data{reduced.words.data()};
+  addend = 19U;
+  for (std::size_t index = 0; index < 4; ++index) {
+    const auto total{static_cast<BignumDoubleWord>(folded_data[index]) +
+                     addend};
+    reduced_data[index] = static_cast<std::uint64_t>(total);
+    addend = static_cast<std::uint64_t>(total >> 64U);
+  }
+
+  const std::uint64_t mask{std::uint64_t{0} - (reduced_data[3] >> 63U)};
+  reduced_data[3] &= 0x7fffffffffffffffULL;
+  for (std::size_t index = 0; index < 4; ++index) {
+    folded_data[index] =
+        (reduced_data[index] & mask) | (folded_data[index] & ~mask);
+  }
+
+  folded.size = 4;
+  return folded;
 }
 
-inline auto edwards_point_conditional_select(
-    const bool condition, const EdwardsPoint &when_true,
-    const EdwardsPoint &when_false) noexcept -> EdwardsPoint {
-  return {.x = bignum_conditional_select(condition, when_true.x, when_false.x),
-          .y = bignum_conditional_select(condition, when_true.y, when_false.y),
-          .z = bignum_conditional_select(condition, when_true.z, when_false.z),
-          .t = bignum_conditional_select(condition, when_true.t, when_false.t)};
+inline auto edwards_point_conditional_select(const bool condition,
+                                             const EdwardsPoint &when_true,
+                                             const EdwardsPoint &when_false,
+                                             const std::size_t words) noexcept
+    -> EdwardsPoint {
+  return {.x = bignum_conditional_select(condition, when_true.x, when_false.x,
+                                         words),
+          .y = bignum_conditional_select(condition, when_true.y, when_false.y,
+                                         words),
+          .z = bignum_conditional_select(condition, when_true.z, when_false.z,
+                                         words),
+          .t = bignum_conditional_select(condition, when_true.t, when_false.t,
+                                         words)};
 }
 
-// The same complete addition as above evaluated over the constant-time field
-// arithmetic, for the signing path where the operands derive from the secret
-// scalar
+// The complete unified Edwards addition formulas in extended coordinates
+// (Hisil, Wong, Carter, and Dawson 2008), which hold for any two points,
+// including equal points and the identity, since the curve coefficient is a
+// square and d is a non-square modulo p. They run over the constant-time field
+// arithmetic, which signing needs for its secret operands and verification
+// reuses on its public ones
 inline auto edwards_point_add_constant_time(
     const EdwardsPoint &left, const EdwardsPoint &right,
-    const EdwardsParameters &parameters, const BarrettContext &field) noexcept
-    -> EdwardsPoint {
+    const EdwardsParameters &parameters,
+    const CurveBarrettContext &field) noexcept -> EdwardsPoint {
   const auto a{field_mod_multiply_ct(left.x, right.x, field)};
   const auto b{field_mod_multiply_ct(left.y, right.y, field)};
   const auto c{field_mod_multiply_ct(
@@ -126,56 +152,168 @@ inline auto edwards_point_add_constant_time(
       field_add_ct(a, b, field), field)};
   const auto f{field_subtract_ct(d, c, field)};
   const auto g{field_add_ct(d, c, field)};
-  const auto h{field_subtract_ct(
-      b, field_mod_multiply_ct(parameters.coefficient_a, a, field), field)};
+  // H = B - a * A, where a is -1 or 1
+  const auto h{parameters.coefficient_a_is_minus_one
+                   ? field_add_ct(b, a, field)
+                   : field_subtract_ct(b, a, field)};
   return EdwardsPoint{.x = field_mod_multiply_ct(e, f, field),
                       .y = field_mod_multiply_ct(g, h, field),
                       .z = field_mod_multiply_ct(f, g, field),
                       .t = field_mod_multiply_ct(e, h, field)};
 }
 
-// For the signing path, where the scalar is secret: a fixed-length
-// double-and-add-always ladder with a masked selection over the complete
-// Edwards formulas evaluated in constant time, so neither the per-bit branch
-// nor the field arithmetic underneath depends on the scalar
+// Dedicated doubling in extended coordinates (Hisil, Wong, Carter, and Dawson
+// 2008, Section 3.3), the formula RFC 8032 Section 5.1.4 recommends for
+// Ed25519, written for a coefficient a of -1 or 1. It reads neither d nor the T
+// coordinate of the input and, like the unified addition, holds for every point
+// of these curves, the identity included. The T coordinate of the result is
+// only computed when requested, as a doubling that feeds another doubling never
+// reads it
+inline auto edwards_point_double_constant_time(
+    const EdwardsPoint &point, const EdwardsParameters &parameters,
+    const CurveBarrettContext &field, const bool extended) noexcept
+    -> EdwardsPoint {
+  const auto a{field_square_ct(point.x, field)};
+  const auto b{field_square_ct(point.y, field)};
+  const auto z_squared{field_square_ct(point.z, field)};
+  const auto c{field_add_ct(z_squared, z_squared, field)};
+  // D = a * A, where a is -1 or 1
+  const auto d{parameters.coefficient_a_is_minus_one
+                   ? field_subtract_ct(CurveBignum{}, a, field)
+                   : a};
+  const auto e{field_subtract_ct(
+      field_square_ct(field_add_ct(point.x, point.y, field), field),
+      field_add_ct(a, b, field), field)};
+  const auto g{field_add_ct(d, b, field)};
+  const auto f{field_subtract_ct(g, c, field)};
+  const auto h{field_subtract_ct(d, b, field)};
+  return EdwardsPoint{.x = field_mod_multiply_ct(e, f, field),
+                      .y = field_mod_multiply_ct(g, h, field),
+                      .z = field_mod_multiply_ct(f, g, field),
+                      .t = extended ? field_mod_multiply_ct(e, h, field)
+                                    : CurveBignum{}};
+}
+
+// For the signing path, where the scalar is secret: a fixed four-bit window
+// ladder over the complete Edwards formulas evaluated in constant time. The
+// window count is fixed by the public field size, every window doubles four
+// times and adds one table entry taken through a masked scan over the whole
+// table, and the complete formulas absorb the identity entry of a zero window,
+// so neither the control flow nor the field arithmetic depends on the scalar
 inline auto edwards_point_scalar_multiply_constant_time(
-    const Bignum &scalar, const EdwardsPoint &point,
+    const CurveBignum &scalar, const EdwardsPoint &point,
+    const EdwardsParameters &parameters) -> EdwardsPoint {
+  const auto &field{parameters.field};
+  std::array<EdwardsPoint, 16> multiples{};
+  // The identity element is (0 : 1 : 1 : 0)
+  multiples[0] = EdwardsPoint{.x = CurveBignum{},
+                              .y = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1),
+                              .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1),
+                              .t = CurveBignum{}};
+  multiples[1] = point;
+  for (std::size_t index = 2; index < multiples.size(); ++index) {
+    multiples[index] = edwards_point_add_constant_time(
+        multiples[index - 1], point, parameters, field);
+  }
+
+  auto result{multiples[0]};
+  const auto windows{(bignum_bit_length(parameters.prime) + 3) / 4};
+  for (std::size_t window = windows; window > 0; --window) {
+    for (std::size_t step = 0; step < 4; ++step) {
+      result = edwards_point_double_constant_time(result, parameters, field,
+                                                  step == 3);
+    }
+
+    std::size_t digit{0};
+    for (std::size_t bit = 0; bit < 4; ++bit) {
+      digit |= static_cast<std::size_t>(
+                   bignum_get_bit_fixed(scalar, ((window - 1) * 4) + bit))
+               << bit;
+    }
+
+    EdwardsPoint selected{};
+    for (std::size_t index = 0; index < multiples.size(); ++index) {
+      selected = edwards_point_conditional_select(
+          digit == index, multiples[index], selected, field.words);
+    }
+
+    result =
+        edwards_point_add_constant_time(result, selected, parameters, field);
+  }
+
+  return result;
+}
+
+// The negation of a point in extended coordinates, (-X : Y : Z : -T)
+inline auto edwards_point_negate(const EdwardsPoint &point,
+                                 const CurveBarrettContext &field) noexcept
+    -> EdwardsPoint {
+  return {.x = field_subtract_ct(CurveBignum{}, point.x, field),
+          .y = point.y,
+          .z = point.z,
+          .t = field_subtract_ct(CurveBignum{}, point.t, field)};
+}
+
+// Compute [first_scalar] first_point + [second_scalar] second_point with
+// Shamir's trick, a single double-and-add over the longer scalar that adds the
+// precomputed sum whenever both scalars have a set bit. Only verification uses
+// it, where both scalars and both points are public, so the bits may steer the
+// additions
+inline auto edwards_point_double_scalar_multiply(
+    const CurveBignum &first_scalar, const EdwardsPoint &first_point,
+    const CurveBignum &second_scalar, const EdwardsPoint &second_point,
     const EdwardsParameters &parameters) -> EdwardsPoint {
-  const auto field{barrett_context(parameters.prime)};
-  EdwardsPoint result{.x = Bignum{},
-                      .y = bignum_from_u64(1),
-                      .z = bignum_from_u64(1),
-                      .t = Bignum{}};
-  const auto scalar_bits{bignum_bit_length(parameters.prime)};
-  for (std::size_t index = scalar_bits; index > 0; --index) {
-    result = edwards_point_add_constant_time(result, result, parameters, field);
-    const auto sum{
-        edwards_point_add_constant_time(result, point, parameters, field)};
-    result = edwards_point_conditional_select(
-        bignum_get_bit_fixed(scalar, index - 1), sum, result);
+  const auto &field{parameters.field};
+  const auto combined{edwards_point_add_constant_time(first_point, second_point,
+                                                      parameters, field)};
+  // The identity element is (0 : 1 : 1 : 0)
+  EdwardsPoint result{.x = CurveBignum{},
+                      .y = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1),
+                      .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1),
+                      .t = CurveBignum{}};
+  const auto first_bits{bignum_bit_length(first_scalar)};
+  const auto second_bits{bignum_bit_length(second_scalar)};
+  const auto bits{first_bits > second_bits ? first_bits : second_bits};
+  for (std::size_t index = bits; index > 0; --index) {
+    const auto first_bit{bignum_get_bit(first_scalar, index - 1)};
+    const auto second_bit{bignum_get_bit(second_scalar, index - 1)};
+    result = edwards_point_double_constant_time(result, parameters, field,
+                                                first_bit || second_bit);
+    if (first_bit && second_bit) {
+      result =
+          edwards_point_add_constant_time(result, combined, parameters, field);
+    } else if (first_bit) {
+      result = edwards_point_add_constant_time(result, first_point, parameters,
+                                               field);
+    } else if (second_bit) {
+      result = edwards_point_add_constant_time(result, second_point, parameters,
+                                               field);
+    }
   }
 
   return result;
 }
 
-// Whether two points are equal, compared without leaving projective space by
-// cross-multiplying through the Z factors
-inline auto edwards_point_equal(const EdwardsPoint &left,
-                                const EdwardsPoint &right, const Bignum &prime)
+// Whether a projective point equals an affine one, whose Z coordinate is one,
+// compared without leaving projective space as X = x * Z and Y = y * Z
+inline auto edwards_point_matches_affine(const EdwardsPoint &point,
+                                         const EdwardsPoint &affine,
+                                         const CurveBarrettContext &field)
     -> bool {
-  return bignum_compare(bignum_mod_multiply(left.x, right.z, prime),
-                        bignum_mod_multiply(right.x, left.z, prime)) == 0 &&
-         bignum_compare(bignum_mod_multiply(left.y, right.z, prime),
-                        bignum_mod_multiply(right.y, left.z, prime)) == 0;
+  return field_equal_ct(
+             point.x, field_mod_multiply_ct(affine.x, point.z, field), field) &&
+         field_equal_ct(point.y,
+                        field_mod_multiply_ct(affine.y, point.z, field), field);
 }
 
 // Encode a point into the little-endian y coordinate with the low bit of x in
 // the final bit (RFC 8032 Section 5.1.2), the inverse of the point decoding
-inline auto edwards_point_encode(const EdwardsPoint &point, const Bignum &prime,
+inline auto edwards_point_encode(const EdwardsPoint &point,
+                                 const EdwardsParameters &parameters,
                                  const std::size_t length) -> std::string {
   // Only the signing path encodes points, and its projective z derives from the
   // secret scalar, so the coordinate recovery is taken in constant time
-  const auto field{barrett_context(prime)};
+  const auto &field{parameters.field};
   const auto z_inverse{field_inverse_ct(point.z, field)};
   const auto x{field_mod_multiply_ct(point.x, z_inverse, field)};
   const auto y{field_mod_multiply_ct(point.y, z_inverse, field)};
@@ -193,20 +331,19 @@ inline auto edwards_point_encode(const EdwardsPoint &point, const Bignum &prime,
 // scalar (RFC 8032 Sections 5.1.5 and 5.2.5). The multiplication is
 // constant-time because the scalar is secret, though the resulting point is
 // public
-inline auto edwards_public_key_point(const Bignum &scalar,
+inline auto edwards_public_key_point(const CurveBignum &scalar,
                                      const EdwardsParameters &parameters,
                                      const std::size_t length) -> std::string {
   return edwards_point_encode(edwards_point_scalar_multiply_constant_time(
                                   scalar, parameters.base, parameters),
-                              parameters.prime, length);
+                              parameters, length);
 }
 
 // Recover an Ed25519 point from its 32-byte encoding (RFC 8032 Section 5.1.3),
-// returning no value when the encoding does not name a point on the curve
+// returning no value when the encoding does not name a point on the curve. The
+// recovery runs over the field arithmetic context of the parameters
 inline auto edwards25519_decode_point(const std::string_view encoding,
-                                      const Bignum &prime,
-                                      const Bignum &coefficient_d,
-                                      const Bignum &square_root_of_minus_one)
+                                      const EdwardsParameters &parameters)
     -> std::optional<EdwardsPoint> {
   if (encoding.size() != 32) {
     return std::nullopt;
@@ -221,53 +358,55 @@ inline auto edwards25519_decode_point(const std::string_view encoding,
   const auto y{bignum_from_bytes_little_endian(bytes)};
 
   // A y coordinate at or beyond the field prime is not a canonical encoding
+  const auto &prime{parameters.prime};
   if (bignum_compare(y, prime) >= 0) {
     return std::nullopt;
   }
 
-  const auto one{bignum_from_u64(1)};
-  const auto y_squared{bignum_mod_multiply(y, y, prime)};
+  const auto &field{parameters.field};
+  const auto one{bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
+  const auto y_squared{field_square_ct(y, field)};
 
   // Solve x^2 = (y^2 - 1) / (d * y^2 + 1) (mod p)
-  const auto numerator{bignum_mod_subtract(y_squared, one, prime)};
-  const auto denominator{bignum_mod_add(
-      bignum_mod_multiply(coefficient_d, y_squared, prime), one, prime)};
+  const auto numerator{field_subtract_ct(y_squared, one, field)};
+  const auto denominator{field_add_ct(
+      field_mod_multiply_ct(parameters.coefficient_d, y_squared, field), one,
+      field)};
 
   // The candidate root is x = numerator * denominator^3 *
   // (numerator * denominator^7)^((p - 5) / 8) (mod p), a single powering that
   // folds in the inversion of the denominator
-  const auto denominator_squared{
-      bignum_mod_multiply(denominator, denominator, prime)};
+  const auto denominator_squared{field_square_ct(denominator, field)};
   const auto denominator_cubed{
-      bignum_mod_multiply(denominator_squared, denominator, prime)};
-  const auto denominator_seventh{bignum_mod_multiply(
-      bignum_mod_multiply(denominator_cubed, denominator_cubed, prime),
-      denominator, prime)};
+      field_mod_multiply_ct(denominator_squared, denominator, field)};
+  const auto denominator_seventh{field_mod_multiply_ct(
+      field_square_ct(denominator_cubed, field), denominator, field)};
   auto exponent{prime};
-  bignum_subtract_in_place(exponent, bignum_from_u64(5));
+  bignum_subtract_in_place(exponent, bignum_from_u64<CURVE_BIGNUM_CAPACITY>(5));
   exponent = bignum_shift_right(exponent, 3);
-  const auto root{
-      bignum_mod_exp(bignum_mod_multiply(numerator, denominator_seventh, prime),
-                     exponent, prime)};
-  auto candidate{bignum_mod_multiply(
-      bignum_mod_multiply(numerator, denominator_cubed, prime), root, prime)};
+  const auto root{field_power_ct(
+      field_mod_multiply_ct(numerator, denominator_seventh, field), exponent,
+      field)};
+  auto candidate{field_mod_multiply_ct(
+      field_mod_multiply_ct(numerator, denominator_cubed, field), root, field)};
 
   // The candidate is correct when denominator * x^2 equals the numerator, off
   // by sqrt(-1) when it equals its negation, and otherwise no root exists
-  const auto check{bignum_mod_multiply(
-      denominator, bignum_mod_multiply(candidate, candidate, prime), prime)};
-  if (bignum_compare(check, numerator) != 0) {
-    const auto negated_numerator{
-        bignum_mod_subtract(Bignum{}, numerator, prime)};
-    if (bignum_compare(check, negated_numerator) != 0) {
+  const auto check{field_mod_multiply_ct(
+      denominator, field_square_ct(candidate, field), field)};
+  if (!field_equal_ct(check, numerator, field)) {
+    if (!field_equal_ct(
+            check, field_subtract_ct(CurveBignum{}, numerator, field), field)) {
       return std::nullopt;
     }
 
-    candidate = bignum_mod_multiply(candidate, square_root_of_minus_one, prime);
+    candidate = field_mod_multiply_ct(
+        candidate, parameters.square_root_of_minus_one, field);
   }
 
   // Reject the non-canonical zero root with a set sign bit, then select the
   // root whose low bit matches the encoded sign
+  bignum_normalize(candidate);
   if (bignum_is_zero(candidate) && sign_bit == 1) {
     return std::nullopt;
   }
@@ -281,48 +420,63 @@ inline auto edwards25519_decode_point(const std::string_view encoding,
   return EdwardsPoint{.x = candidate,
                       .y = y,
                       .z = one,
-                      .t = bignum_mod_multiply(candidate, y, prime)};
+                      .t = field_mod_multiply_ct(candidate, y, field)};
 }
 
 // The Edwards25519 domain parameters (RFC 8032 Section 5.1)
-inline auto edwards25519() -> EdwardsParameters {
+inline auto edwards25519_parameters() -> EdwardsParameters {
   EdwardsParameters parameters;
-  parameters.prime = bignum_from_hex(
+  parameters.prime = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
       "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
-  parameters.order = bignum_from_hex(
+  parameters.order = bignum_from_hex<CURVE_BIGNUM_CAPACITY>(
       "1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed");
 
   // The curve coefficient a is -1 (mod p)
   parameters.coefficient_a = parameters.prime;
-  bignum_subtract_in_place(parameters.coefficient_a, bignum_from_u64(1));
+  bignum_subtract_in_place(parameters.coefficient_a,
+                           bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1));
+  parameters.coefficient_a_is_minus_one = true;
 
   // d = -121665 / 121666 (mod p)
   auto negated_numerator{parameters.prime};
-  bignum_subtract_in_place(negated_numerator, bignum_from_u64(121665));
+  bignum_subtract_in_place(negated_numerator,
+                           bignum_from_u64<CURVE_BIGNUM_CAPACITY>(121665));
   parameters.coefficient_d = bignum_mod_multiply(
       negated_numerator,
-      bignum_mod_inverse(bignum_from_u64(121666), parameters.prime),
+      bignum_mod_inverse(bignum_from_u64<CURVE_BIGNUM_CAPACITY>(121666),
+                         parameters.prime),
       parameters.prime);
 
   // sqrt(-1) = 2^((p - 1) / 4) (mod p), used to recover the second root
   auto root_exponent{parameters.prime};
-  bignum_subtract_in_place(root_exponent, bignum_from_u64(1));
+  bignum_subtract_in_place(root_exponent,
+                           bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1));
   root_exponent = bignum_shift_right(root_exponent, 2);
-  const auto square_root_of_minus_one{
-      bignum_mod_exp(bignum_from_u64(2), root_exponent, parameters.prime)};
+  parameters.square_root_of_minus_one =
+      bignum_mod_exp(bignum_from_u64<CURVE_BIGNUM_CAPACITY>(2), root_exponent,
+                     parameters.prime);
+  parameters.field = barrett_context(parameters.prime);
+  parameters.field.reduce = &field_reduce_25519_ct;
+  parameters.order_field = barrett_context(parameters.order);
 
   // The base point is recovered from its canonical encoding, y = 4/5 with a
   // clear sign bit (RFC 8032 Section 5.1)
   std::string base_encoding;
   base_encoding.push_back('\x58');
   base_encoding.append(31, '\x66');
-  parameters.base = edwards25519_decode_point(base_encoding, parameters.prime,
-                                              parameters.coefficient_d,
-                                              square_root_of_minus_one)
-                        .value();
+  parameters.base =
+      edwards25519_decode_point(base_encoding, parameters).value();
   return parameters;
 }
 
+// The Edwards25519 domain parameters derived once and shared, as every signing
+// and verification would otherwise repeat the modular inverse and the
+// exponentiations the derivation spends
+inline auto edwards25519() -> const EdwardsParameters & {
+  static const EdwardsParameters PARAMETERS{edwards25519_parameters()};
+  return PARAMETERS;
+}
+
 // Verify an Ed25519 signature over a message (RFC 8032 Section 5.1.7), given
 // the 32-byte public key and the 64-byte signature
 inline auto edwards25519_verify(const std::string_view public_key,
@@ -332,16 +486,8 @@ inline auto edwards25519_verify(const std::string_view public_key,
     return false;
   }
 
-  const auto parameters{edwards25519()};
-  auto square_root_exponent{parameters.prime};
-  bignum_subtract_in_place(square_root_exponent, bignum_from_u64(1));
-  square_root_exponent = bignum_shift_right(square_root_exponent, 2);
-  const auto square_root_of_minus_one{bignum_mod_exp(
-      bignum_from_u64(2), square_root_exponent, parameters.prime)};
-
-  const auto public_point{edwards25519_decode_point(
-      public_key, parameters.prime, parameters.coefficient_d,
-      square_root_of_minus_one)};
+  const auto &parameters{edwards25519()};
+  const auto public_point{edwards25519_decode_point(public_key, parameters)};
   if (!public_point.has_value()) {
     return false;
   }
@@ -349,9 +495,7 @@ inline auto edwards25519_verify(const std::string_view public_key,
   // The signature is the encoded point R followed by the little-endian scalar
   // S, which must lie below the group order
   const auto encoded_r{signature.substr(0, 32)};
-  const auto point_r{edwards25519_decode_point(encoded_r, parameters.prime,
-                                               parameters.coefficient_d,
-                                               square_root_of_minus_one)};
+  const auto point_r{edwards25519_decode_point(encoded_r, parameters)};
   if (!point_r.has_value()) {
     return false;
   }
@@ -372,14 +516,14 @@ inline auto edwards25519_verify(const std::string_view public_key,
       reinterpret_cast<const char *>(digest.data()), digest.size()})};
   bignum_reduce(scalar_k, parameters.order);
 
-  // The signature holds when [S]B = R + [k]A
-  const auto left{
-      edwards_point_scalar_multiply(scalar_s, parameters.base, parameters)};
-  const auto right{edwards_point_add(
-      point_r.value(),
-      edwards_point_scalar_multiply(scalar_k, public_point.value(), parameters),
+  // The signature holds when [S]B = R + [k]A, checked as [S]B + [k](-A) = R so
+  // that both scalar multiplications share a single pass
+  const auto combination{edwards_point_double_scalar_multiply(
+      scalar_s, parameters.base, scalar_k,
+      edwards_point_negate(public_point.value(), parameters.field),
       parameters)};
-  return edwards_point_equal(left, right, parameters.prime);
+  return edwards_point_matches_affine(combination, point_r.value(),
+                                      parameters.field);
 }
 
 // Prune the 32-byte secret scalar in place (RFC 8032 Section 5.1.5): "The
@@ -402,7 +546,7 @@ inline auto edwards25519_public_key(const std::string_view secret)
     return std::nullopt;
   }
 
-  const auto parameters{edwards25519()};
+  const auto &parameters{edwards25519()};
   auto hashed{sha512_digest(secret)};
   const SecureBufferScope hashed_scope{hashed.data(), hashed.size()};
   const std::string_view digest{reinterpret_cast<const char *>(hashed.data()),
@@ -422,7 +566,7 @@ inline auto edwards25519_sign(const std::string_view secret,
     return std::nullopt;
   }
 
-  const auto parameters{edwards25519()};
+  const auto &parameters{edwards25519()};
   // The key derivation hash carries both the secret scalar and the nonce
   // prefix, so it and everything derived from it below is wiped before
   // returning
@@ -456,7 +600,7 @@ inline auto edwards25519_sign(const std::string_view secret,
   const auto encoded_r{
       edwards_point_encode(edwards_point_scalar_multiply_constant_time(
                                scalar_r, parameters.base, parameters),
-                           parameters.prime, 32)};
+                           parameters, 32)};
 
   // k = SHA-512(R || A || M) reduced, then S = (r + k * a) mod L. The k * a
   // product carries the secret scalar, so it is wiped; r, k, and the resulting
@@ -473,7 +617,7 @@ inline auto edwards25519_sign(const std::string_view secret,
   // nonce, so both run over the constant-time field arithmetic modulo the
   // order; k is public and r, k, and the resulting S are the public signature
   // material
-  const auto order_field{barrett_context(parameters.order)};
+  const auto &order_field{parameters.order_field};
   auto scalar_a_reduced{barrett_reduce(scalar_a, order_field)};
   const SecureBignumScope scalar_a_reduced_scope{scalar_a_reduced};
   auto challenge_product{
@@ -489,10 +633,10 @@ inline auto edwards25519_sign(const std::string_view secret,
 }
 
 // Recover an Ed448 point from its 57-byte encoding (RFC 8032 Section 5.2.3),
-// returning no value when the encoding does not name a point on the curve
+// returning no value when the encoding does not name a point on the curve. The
+// recovery runs over the field arithmetic context of the parameters
 inline auto edwards448_decode_point(const std::string_view encoding,
-                                    const Bignum &prime,
-                                    const Bignum &coefficient_d)
+                                    const EdwardsParameters &parameters)
     -> std::optional<EdwardsPoint> {
   if (encoding.size() != 57) {
     return std::nullopt;
@@ -507,50 +651,52 @@ inline auto edwards448_decode_point(const std::string_view encoding,
   const auto y{bignum_from_bytes_little_endian(bytes)};
 
   // A y coordinate at or beyond the field prime is not a canonical encoding
+  const auto &prime{parameters.prime};
   if (bignum_compare(y, prime) >= 0) {
     return std::nullopt;
   }
 
-  const auto one{bignum_from_u64(1)};
-  const auto y_squared{bignum_mod_multiply(y, y, prime)};
+  const auto &field{parameters.field};
+  const auto one{bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
+  const auto y_squared{field_square_ct(y, field)};
 
   // Solve x^2 = (y^2 - 1) / (d * y^2 - 1) (mod p)
-  const auto numerator{bignum_mod_subtract(y_squared, one, prime)};
-  const auto denominator{bignum_mod_subtract(
-      bignum_mod_multiply(coefficient_d, y_squared, prime), one, prime)};
+  const auto numerator{field_subtract_ct(y_squared, one, field)};
+  const auto denominator{field_subtract_ct(
+      field_mod_multiply_ct(parameters.coefficient_d, y_squared, field), one,
+      field)};
 
   // The candidate root is x = numerator^3 * denominator *
   // (numerator^5 * denominator^3)^((p - 3) / 4) (mod p), the field having
   // p congruent to 3 modulo 4
-  const auto numerator_squared{
-      bignum_mod_multiply(numerator, numerator, prime)};
+  const auto numerator_squared{field_square_ct(numerator, field)};
   const auto numerator_cubed{
-      bignum_mod_multiply(numerator_squared, numerator, prime)};
+      field_mod_multiply_ct(numerator_squared, numerator, field)};
   const auto numerator_fifth{
-      bignum_mod_multiply(numerator_squared, numerator_cubed, prime)};
-  const auto denominator_squared{
-      bignum_mod_multiply(denominator, denominator, prime)};
+      field_mod_multiply_ct(numerator_squared, numerator_cubed, field)};
+  const auto denominator_squared{field_square_ct(denominator, field)};
   const auto denominator_cubed{
-      bignum_mod_multiply(denominator_squared, denominator, prime)};
+      field_mod_multiply_ct(denominator_squared, denominator, field)};
   auto exponent{prime};
-  bignum_subtract_in_place(exponent, bignum_from_u64(3));
+  bignum_subtract_in_place(exponent, bignum_from_u64<CURVE_BIGNUM_CAPACITY>(3));
   exponent = bignum_shift_right(exponent, 2);
-  const auto root{bignum_mod_exp(
-      bignum_mod_multiply(numerator_fifth, denominator_cubed, prime), exponent,
-      prime)};
-  auto candidate{bignum_mod_multiply(
-      bignum_mod_multiply(numerator_cubed, denominator, prime), root, prime)};
+  const auto root{field_power_ct(
+      field_mod_multiply_ct(numerator_fifth, denominator_cubed, field),
+      exponent, field)};
+  auto candidate{field_mod_multiply_ct(
+      field_mod_multiply_ct(numerator_cubed, denominator, field), root, field)};
 
   // The candidate is correct when denominator * x^2 equals the numerator, and
   // otherwise no root exists, as the field admits a single square root
-  const auto check{bignum_mod_multiply(
-      denominator, bignum_mod_multiply(candidate, candidate, prime), prime)};
-  if (bignum_compare(check, numerator) != 0) {
+  const auto check{field_mod_multiply_ct(
+      denominator, field_square_ct(candidate, field), field)};
+  if (!field_equal_ct(check, numerator, field)) {
     return std::nullopt;
   }
 
   // Reject the non-canonical zero root with a set sign bit, then select the
   // root whose low bit matches the encoded sign
+  bignum_normalize(candidate);
   if (bignum_is_zero(candidate) && sign_bit == 1) {
     return std::nullopt;
   }
@@ -564,33 +710,43 @@ inline auto edwards448_decode_point(const std::string_view encoding,
   return EdwardsPoint{.x = candidate,
                       .y = y,
                       .z = one,
-                      .t = bignum_mod_multiply(candidate, y, prime)};
+                      .t = field_mod_multiply_ct(candidate, y, field)};
 }
 
 // The Edwards448 domain parameters (RFC 8032 Section 5.2)
-inline auto edwards448() -> EdwardsParameters {
+inline auto edwards448_parameters() -> EdwardsParameters {
   EdwardsParameters parameters;
   // clang-format off
-  parameters.prime = bignum_from_hex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-  parameters.order = bignum_from_hex("3fffffffffffffffffffffffffffffffffffffffffffffffffffffff7cca23e9c44edb49aed63690216cc2728dc58f552378c292ab5844f3");
+  parameters.prime = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+  parameters.order = bignum_from_hex<CURVE_BIGNUM_CAPACITY>("3fffffffffffffffffffffffffffffffffffffffffffffffffffffff7cca23e9c44edb49aed63690216cc2728dc58f552378c292ab5844f3");
   // clang-format on
 
   // The curve coefficient a is 1, and d is -39081 (mod p)
-  parameters.coefficient_a = bignum_from_u64(1);
+  parameters.coefficient_a = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1);
+  parameters.coefficient_a_is_minus_one = false;
   parameters.coefficient_d = parameters.prime;
-  bignum_subtract_in_place(parameters.coefficient_d, bignum_from_u64(39081));
+  bignum_subtract_in_place(parameters.coefficient_d,
+                           bignum_from_u64<CURVE_BIGNUM_CAPACITY>(39081));
 
   // The base point is recovered from its canonical 57-octet encoding (RFC 8032
   // Section 5.2)
   // clang-format off
-  const auto base_encoding{bignum_to_bytes(bignum_from_hex("14fa30f25b790898adc8d74e2c13bdfdc4397ce61cffd33ad7c2a0051e9c78874098a36c7373ea4b62c7c9563720768824bcb66e71463f6900"), 57)};
+  const auto base_encoding{bignum_to_bytes(bignum_from_hex<CURVE_BIGNUM_CAPACITY>("14fa30f25b790898adc8d74e2c13bdfdc4397ce61cffd33ad7c2a0051e9c78874098a36c7373ea4b62c7c9563720768824bcb66e71463f6900"), 57)};
   // clang-format on
-  parameters.base = edwards448_decode_point(base_encoding, parameters.prime,
-                                            parameters.coefficient_d)
-                        .value();
+  parameters.field = barrett_context(parameters.prime);
+  parameters.order_field = barrett_context(parameters.order);
+  parameters.base = edwards448_decode_point(base_encoding, parameters).value();
   return parameters;
 }
 
+// The Edwards448 domain parameters derived once and shared, as every signing
+// and verification would otherwise repeat the exponentiation that decoding the
+// base point spends
+inline auto edwards448() -> const EdwardsParameters & {
+  static const EdwardsParameters PARAMETERS{edwards448_parameters()};
+  return PARAMETERS;
+}
+
 // Verify an Ed448 signature over a message (RFC 8032 Section 5.2.7), given the
 // 57-byte public key and the 114-byte signature
 inline auto edwards448_verify(const std::string_view public_key,
@@ -600,9 +756,8 @@ inline auto edwards448_verify(const std::string_view public_key,
     return false;
   }
 
-  const auto parameters{edwards448()};
-  const auto public_point{edwards448_decode_point(public_key, parameters.prime,
-                                                  parameters.coefficient_d)};
+  const auto &parameters{edwards448()};
+  const auto public_point{edwards448_decode_point(public_key, parameters)};
   if (!public_point.has_value()) {
     return false;
   }
@@ -610,8 +765,7 @@ inline auto edwards448_verify(const std::string_view public_key,
   // The signature is the encoded point R followed by the little-endian scalar
   // S, which must lie below the group order
   const auto encoded_r{signature.substr(0, 57)};
-  const auto point_r{edwards448_decode_point(encoded_r, parameters.prime,
-                                             parameters.coefficient_d)};
+  const auto point_r{edwards448_decode_point(encoded_r, parameters)};
   if (!point_r.has_value()) {
     return false;
   }
@@ -634,14 +788,14 @@ inline auto edwards448_verify(const std::string_view public_key,
   auto scalar_k{bignum_from_bytes_little_endian(digest)};
   bignum_reduce(scalar_k, parameters.order);
 
-  // The signature holds when [S]B = R + [k]A
-  const auto left{
-      edwards_point_scalar_multiply(scalar_s, parameters.base, parameters)};
-  const auto right{edwards_point_add(
-      point_r.value(),
-      edwards_point_scalar_multiply(scalar_k, public_point.value(), parameters),
+  // The signature holds when [S]B = R + [k]A, checked as [S]B + [k](-A) = R so
+  // that both scalar multiplications share a single pass
+  const auto combination{edwards_point_double_scalar_multiply(
+      scalar_s, parameters.base, scalar_k,
+      edwards_point_negate(public_point.value(), parameters.field),
       parameters)};
-  return edwards_point_equal(left, right, parameters.prime);
+  return edwards_point_matches_affine(combination, point_r.value(),
+                                      parameters.field);
 }
 
 // Prune the 57-byte secret scalar in place (RFC 8032 Section 5.2.5): "The two
@@ -665,7 +819,7 @@ inline auto edwards448_public_key(const std::string_view secret)
     return std::nullopt;
   }
 
-  const auto parameters{edwards448()};
+  const auto &parameters{edwards448()};
   auto digest{shake256(secret, 114)};
   const SecureStringScope digest_scope{digest};
   std::string scalar_bytes{digest.substr(0, 57)};
@@ -683,7 +837,7 @@ inline auto edwards448_sign(const std::string_view secret,
     return std::nullopt;
   }
 
-  const auto parameters{edwards448()};
+  const auto &parameters{edwards448()};
   // The key derivation hash carries both the secret scalar and the nonce
   // prefix, so it and everything derived from it below is wiped before
   // returning
@@ -718,7 +872,7 @@ inline auto edwards448_sign(const std::string_view secret,
   const auto encoded_r{
       edwards_point_encode(edwards_point_scalar_multiply_constant_time(
                                scalar_r, parameters.base, parameters),
-                           parameters.prime, 57)};
+                           parameters, 57)};
 
   // k = SHAKE256(dom4 || R || A || M) reduced, then S = (r + k * a) mod L. The
   // k * a product carries the secret scalar, so it is wiped; r, k, and the
@@ -734,7 +888,7 @@ inline auto edwards448_sign(const std::string_view secret,
   // nonce, so both run over the constant-time field arithmetic modulo the
   // order; k is public and r, k, and the resulting S are the public signature
   // material
-  const auto order_field{barrett_context(parameters.order)};
+  const auto &order_field{parameters.order_field};
   auto scalar_a_reduced{barrett_reduce(scalar_a, order_field)};
   const SecureBignumScope scalar_a_reduced_scope{scalar_a_reduced};
   auto challenge_product{
diff --git a/vendor/core/src/core/crypto/crypto_helpers.h b/vendor/core/src/core/crypto/crypto_helpers.h
index ee5816c3..62d7a69e 100644
--- a/vendor/core/src/core/crypto/crypto_helpers.h
+++ b/vendor/core/src/core/crypto/crypto_helpers.h
@@ -10,7 +10,6 @@
 
 #include <cstddef>     // std::size_t
 #include <cstdint>     // std::uint8_t
-#include <optional>    // std::optional, std::nullopt
 #include <string>      // std::string
 #include <string_view> // std::string_view
 #include <utility>     // std::unreachable
@@ -80,23 +79,6 @@ inline auto octets_below_fixed(const std::string_view value,
   return borrow == 1;
 }
 
-// Whether a signature is a well-formed representative for the modulus. RFC 8017
-// Section 8.2.2 step 1 and Section 8.1.2 step 1: "If the length of the
-// signature S is not k octets, output "invalid signature" and stop". The length
-// is checked because the range comparison reads both operands as bare integers,
-// so a signature that merely dropped a leading zero octet would denote the same
-// value and verify, giving a second encoding of one signature. Section 5.2.2
-// then requires the range check, so that an unreduced signature, which an
-// attacker forges by adding the modulus without changing the modular
-// exponentiation result, is rejected. The modulus is stripped for the length so
-// that a stored ASN.1 sign octet cannot inflate k
-inline auto rsa_signature_acceptable(const std::string_view signature,
-                                     const std::string_view modulus) noexcept
-    -> bool {
-  return signature.size() == strip_left(modulus, '\x00').size() &&
-         octets_below(signature, modulus);
-}
-
 // Whether an RSA public exponent is acceptable for the modulus: odd and in the
 // range [3, n) (RFC 8017 Section 3.1). An even exponent is not invertible
 // modulo the totient, e = 1 leaves the signature equal to the padded message
@@ -131,39 +113,6 @@ inline auto curve_field_bytes(const EllipticCurve curve) noexcept
   std::unreachable();
 }
 
-// The order bit length of each curve, which the platform key generators take as
-// the requested key size. It is not the field width in bits, since P-521 has a
-// 521-bit order that does not fill its 66 octets
-inline auto curve_bit_length(const EllipticCurve curve) noexcept
-    -> std::size_t {
-  switch (curve) {
-    case EllipticCurve::P256:
-      return 256;
-    case EllipticCurve::P384:
-      return 384;
-    case EllipticCurve::P521:
-      return 521;
-  }
-
-  std::unreachable();
-}
-
-// The inverse mapping, identifying the curve from its field width, so a backend
-// that reports a key only by coordinate size resolves it the same way
-inline auto ec_curve_from_field_bytes(const std::size_t field_bytes) noexcept
-    -> std::optional<EllipticCurve> {
-  switch (field_bytes) {
-    case 32:
-      return EllipticCurve::P256;
-    case 48:
-      return EllipticCurve::P384;
-    case 66:
-      return EllipticCurve::P521;
-    default:
-      return std::nullopt;
-  }
-}
-
 // The group order of each NIST prime curve as big-endian octets (FIPS 186-4
 // Appendix D.1.2), so a private scalar can be range-checked against it
 inline auto curve_order_bytes(const EllipticCurve curve) -> std::string {
@@ -223,8 +172,7 @@ inline auto ec_private_scalar_in_range(const std::string_view scalar,
   return within != 0;
 }
 
-// The public key and signature octet lengths are fixed per curve (RFC 8032
-// Section 5.1.2 and Section 5.1.6)
+// The public key octet length is fixed per curve (RFC 8032 Section 5.1.2)
 inline auto eddsa_public_key_bytes(const EdwardsCurve curve) noexcept
     -> std::size_t {
   switch (curve) {
@@ -237,18 +185,6 @@ inline auto eddsa_public_key_bytes(const EdwardsCurve curve) noexcept
   std::unreachable();
 }
 
-inline auto eddsa_signature_bytes(const EdwardsCurve curve) noexcept
-    -> std::size_t {
-  switch (curve) {
-    case EdwardsCurve::Ed25519:
-      return 64;
-    case EdwardsCurve::Ed448:
-      return 114;
-  }
-
-  std::unreachable();
-}
-
 inline auto digest_message(const SignatureHashFunction hash,
                            const std::string_view message) -> std::string {
   switch (hash) {
diff --git a/vendor/core/src/core/crypto/crypto_other.h b/vendor/core/src/core/crypto/crypto_other.h
index 66c1b705..d97e3d01 100644
--- a/vendor/core/src/core/crypto/crypto_other.h
+++ b/vendor/core/src/core/crypto/crypto_other.h
@@ -26,6 +26,13 @@ struct PrivateKey::Internal {
   std::string modulus;
   std::string public_exponent;
   std::string private_exponent;
+  // The two-prime CRT components (RFC 8017 Section 3.2), left empty for the
+  // multi-prime form, whose private operation uses the private exponent alone
+  std::string prime1;
+  std::string prime2;
+  std::string exponent1;
+  std::string exponent2;
+  std::string coefficient;
   std::string scalar;
   EllipticCurve elliptic_curve;
   std::string edwards_seed;
diff --git a/vendor/core/src/core/crypto/crypto_random_other.cc b/vendor/core/src/core/crypto/crypto_random_other.cc
index 9f675c24..1a256a51 100644
--- a/vendor/core/src/core/crypto/crypto_random_other.cc
+++ b/vendor/core/src/core/crypto/crypto_random_other.cc
@@ -15,35 +15,6 @@
 
 namespace sourcemeta::core {
 
-namespace {
-
-// Read from the kernel random device, used only on the rare platforms where
-// getentropy is present but the kernel call is unavailable
-auto fill_from_random_device(const std::span<std::uint8_t> bytes) -> void {
-  std::ifstream device{"/dev/urandom", std::ios::binary};
-  if (!device) {
-    throw std::runtime_error("Could not open the system random device");
-  }
-
-  // A single read can return fewer bytes than requested when interrupted by a
-  // signal, so the buffer is filled across as many reads as it takes, failing
-  // only when a read makes no progress or the device faults
-  std::size_t offset{0};
-  while (offset < bytes.size()) {
-    device.read(reinterpret_cast<char *>(bytes.data() + offset),
-                static_cast<std::streamsize>(bytes.size() - offset));
-    const auto count{device.gcount()};
-    if (device.bad() || count <= 0) {
-      throw std::runtime_error("Could not read from the system random device");
-    }
-
-    offset += static_cast<std::size_t>(count);
-    device.clear();
-  }
-}
-
-} // namespace
-
 auto fill_random_bytes(std::span<std::uint8_t> bytes) -> void {
   // getentropy draws from the kernel cryptographic generator and fails closed,
   // never returning low-quality bytes, but fills at most 256 bytes per call
@@ -52,7 +23,30 @@ auto fill_random_bytes(std::span<std::uint8_t> bytes) -> void {
   while (offset < bytes.size()) {
     const auto chunk{std::min(bytes.size() - offset, maximum_per_call)};
     if (getentropy(bytes.data() + offset, chunk) != 0) {
-      fill_from_random_device(bytes.subspan(offset));
+      // Read the rest from the kernel random device, which is only needed on
+      // the rare platforms where getentropy is present but the kernel call is
+      // unavailable
+      std::ifstream device{"/dev/urandom", std::ios::binary};
+      if (!device) {
+        throw std::runtime_error("Could not open the system random device");
+      }
+
+      // A single read can return fewer bytes than requested when interrupted
+      // by a signal, so the buffer is filled across as many reads as it takes,
+      // failing only when a read makes no progress or the device faults
+      while (offset < bytes.size()) {
+        device.read(reinterpret_cast<char *>(bytes.data() + offset),
+                    static_cast<std::streamsize>(bytes.size() - offset));
+        const auto count{device.gcount()};
+        if (device.bad() || count <= 0) {
+          throw std::runtime_error(
+              "Could not read from the system random device");
+        }
+
+        offset += static_cast<std::size_t>(count);
+        device.clear();
+      }
+
       return;
     }
 
diff --git a/vendor/core/src/core/crypto/crypto_rsa_oaep_other.cc b/vendor/core/src/core/crypto/crypto_rsa_oaep_other.cc
index d23945bc..d9fc8adc 100644
--- a/vendor/core/src/core/crypto/crypto_rsa_oaep_other.cc
+++ b/vendor/core/src/core/crypto/crypto_rsa_oaep_other.cc
@@ -5,6 +5,7 @@
 #include "crypto_helpers.h"
 #include "crypto_other.h"
 #include "crypto_random.h"
+#include "crypto_rsa_other.h"
 #include "crypto_sha1_other.h"
 
 #include <cstddef>     // std::size_t
@@ -154,10 +155,7 @@ auto rsa_oaep_decrypt(const PrivateKey &key, const RSAOAEPHash hash,
     return std::nullopt;
   }
 
-  auto exponent{bignum_from_bytes(internal->private_exponent)};
-  const SecureBignumScope exponent_scope{exponent};
-  auto message_number{
-      bignum_mod_exp_ct(ciphertext_number, exponent, barrett_context(modulus))};
+  auto message_number{rsa_private_operation(*internal, ciphertext_number)};
   const SecureBignumScope message_scope{message_number};
   const auto encoded_message{bignum_to_bytes(message_number, key_length)};
 
diff --git a/vendor/core/src/core/crypto/crypto_rsa_other.h b/vendor/core/src/core/crypto/crypto_rsa_other.h
new file mode 100644
index 00000000..efa5b993
--- /dev/null
+++ b/vendor/core/src/core/crypto/crypto_rsa_other.h
@@ -0,0 +1,144 @@
+#ifndef SOURCEMETA_CORE_CRYPTO_RSA_OTHER_H_
+#define SOURCEMETA_CORE_CRYPTO_RSA_OTHER_H_
+
+// The RSA private key operation for the reference backend, shared by signing
+// (RSASP1, RFC 8017 Section 5.2.1) and decryption (RSADP, RFC 8017 Section
+// 5.1.2), which compute the same function of the private key
+
+#include "crypto_bignum.h"
+#include "crypto_other.h"
+
+#include <cstddef>  // std::size_t
+#include <cstdint>  // std::uint64_t
+#include <optional> // std::optional, std::nullopt
+
+namespace sourcemeta::core {
+
+// RFC 8017 Section 5.1.2 step 2.b for the two-prime form: exponentiate modulo
+// each prime with its CRT exponent and recombine, which costs about a quarter
+// of one exponentiation modulo the modulus. Every value derives from the secret
+// primes, so their Barrett constants are built in constant time and every
+// intermediate is wiped. Returns no value when a prime is too short for the
+// Barrett reduction of the input, which the word lengths fixed by the public
+// key size decide
+inline auto rsa_private_operation_crt(const PrivateKey::Internal &key,
+                                      const Bignum &input,
+                                      const std::size_t modulus_words)
+    -> std::optional<Bignum> {
+  auto prime1{bignum_from_bytes(key.prime1)};
+  const SecureBignumScope prime1_scope{prime1};
+  auto prime2{bignum_from_bytes(key.prime2)};
+  const SecureBignumScope prime2_scope{prime2};
+  if (bignum_is_zero(prime1) || bignum_is_zero(prime2) ||
+      modulus_words > 2 * prime1.size || modulus_words > 2 * prime2.size) {
+    return std::nullopt;
+  }
+
+  auto context1{barrett_context_ct(prime1)};
+  const SecureBignumScope context1_modulus_scope{context1.modulus};
+  const SecureBignumScope context1_factor_scope{context1.factor};
+  auto context2{barrett_context_ct(prime2)};
+  const SecureBignumScope context2_modulus_scope{context2.modulus};
+  const SecureBignumScope context2_factor_scope{context2.factor};
+
+  // RFC 8017 Section 5.1.2 step 2.b.i: "Let m_1 = c^dP mod p and m_2 = c^dQ
+  // mod q"
+  auto exponent1{bignum_from_bytes(key.exponent1)};
+  const SecureBignumScope exponent1_scope{exponent1};
+  auto message1{bignum_mod_exp_ct(input, exponent1, context1)};
+  const SecureBignumScope message1_scope{message1};
+  auto exponent2{bignum_from_bytes(key.exponent2)};
+  const SecureBignumScope exponent2_scope{exponent2};
+  auto message2{bignum_mod_exp_ct(input, exponent2, context2)};
+  const SecureBignumScope message2_scope{message2};
+
+  // RFC 8017 Section 5.1.2 step 2.b.iii: "Let h = (m_1 - m_2) * qInv mod p"
+  auto message2_reduced{barrett_reduce(message2, context1)};
+  const SecureBignumScope message2_reduced_scope{message2_reduced};
+  auto difference{field_subtract_ct(message1, message2_reduced, context1)};
+  const SecureBignumScope difference_scope{difference};
+  auto coefficient{bignum_from_bytes(key.coefficient)};
+  const SecureBignumScope coefficient_scope{coefficient};
+  auto coefficient_reduced{barrett_reduce(coefficient, context1)};
+  const SecureBignumScope coefficient_reduced_scope{coefficient_reduced};
+  auto lift{field_mod_multiply_ct(difference, coefficient_reduced, context1)};
+  const SecureBignumScope lift_scope{lift};
+
+  // RFC 8017 Section 5.1.2 step 2.b.iv: "Let m = m_2 + q * h"
+  auto product{
+      bignum_multiply_fixed(prime2, lift, context2.words, context1.words)};
+  const SecureBignumScope product_scope{product};
+  const auto width{context1.words + context2.words};
+  const auto *product_data{product.words.data()};
+  const auto *message2_data{message2.words.data()};
+  Bignum result;
+  const SecureBignumScope result_scope{result};
+  auto *result_data{result.words.data()};
+  std::uint64_t carry{0};
+  for (std::size_t index = 0; index < width; ++index) {
+    const auto total{static_cast<BignumDoubleWord>(product_data[index]) +
+                     message2_data[index] + carry};
+    result_data[index] = static_cast<std::uint64_t>(total);
+    carry = static_cast<std::uint64_t>(total >> 64U);
+  }
+
+  result.size = width;
+  return result;
+}
+
+// Whether raising the candidate to the public exponent modulo the modulus gives
+// back the input, which catches a CRT result corrupted by a fault or by
+// inconsistent key components before it is released. The exponent is public,
+// so its bits may steer the loop, while the multiplications stay constant time
+// as the candidate may be a decrypted secret
+inline auto rsa_private_result_matches(const Bignum &candidate,
+                                       const Bignum &input,
+                                       const Bignum &public_exponent,
+                                       const BarrettContext &context) noexcept
+    -> bool {
+  const auto width{context.words};
+  Bignum power;
+  const SecureBignumScope power_scope{power};
+  power.words[0] = 1;
+  power.size = width;
+  for (std::size_t index = bignum_bit_length(public_exponent); index > 0;
+       --index) {
+    power = field_square_ct(power, context);
+    if (bignum_get_bit(public_exponent, index - 1)) {
+      power = field_mod_multiply_ct(power, candidate, context);
+    }
+  }
+
+  return field_equal_ct(power, input, context);
+}
+
+// RSASP1 and RSADP (RFC 8017 Sections 5.2.1 and 5.1.2) over an input already
+// known to lie below the modulus. The two-prime form takes the CRT path, whose
+// result is released only once raising it back to the public exponent
+// reproduces the input, so a fault or inconsistent CRT components fall back to
+// the private exponent rather than leak a corrupted value. A multi-prime key
+// carries no CRT components here and uses the private exponent directly
+inline auto rsa_private_operation(const PrivateKey::Internal &key,
+                                  const Bignum &input) -> Bignum {
+  const auto modulus{bignum_from_bytes(key.modulus)};
+  const auto context{barrett_context(modulus)};
+  if (!key.prime1.empty()) {
+    auto candidate{rsa_private_operation_crt(key, input, modulus.size)};
+    if (candidate.has_value()) {
+      const SecureBignumScope candidate_scope{candidate.value()};
+      if (rsa_private_result_matches(candidate.value(), input,
+                                     bignum_from_bytes(key.public_exponent),
+                                     context)) {
+        return candidate.value();
+      }
+    }
+  }
+
+  auto exponent{bignum_from_bytes(key.private_exponent)};
+  const SecureBignumScope exponent_scope{exponent};
+  return bignum_mod_exp_ct(input, exponent, context);
+}
+
+} // namespace sourcemeta::core
+
+#endif
diff --git a/vendor/core/src/core/crypto/crypto_sha1_other.cc b/vendor/core/src/core/crypto/crypto_sha1_other.cc
index e5a7a47d..67d4c5ab 100644
--- a/vendor/core/src/core/crypto/crypto_sha1_other.cc
+++ b/vendor/core/src/core/crypto/crypto_sha1_other.cc
@@ -41,9 +41,10 @@ inline auto sha1_process_block(const unsigned char *block,
     -> void {
   // Decode 16 big-endian 32-bit words from the block
   std::array<std::uint32_t, 80> schedule;
+  auto *schedule_data = schedule.data();
   for (std::uint64_t word_index = 0; word_index < 16u; ++word_index) {
     const std::uint64_t byte_index = word_index * 4u;
-    schedule[word_index] =
+    schedule_data[word_index] =
         (static_cast<std::uint32_t>(block[byte_index]) << 24u) |
         (static_cast<std::uint32_t>(block[byte_index + 1u]) << 16u) |
         (static_cast<std::uint32_t>(block[byte_index + 2u]) << 8u) |
@@ -52,13 +53,14 @@ inline auto sha1_process_block(const unsigned char *block,
 
   // Extend the message schedule (RFC 3174 Section 6.1 step b)
   for (std::uint64_t index = 16u; index < 80u; ++index) {
-    schedule[index] =
-        rotate_left(schedule[index - 3u] ^ schedule[index - 8u] ^
-                        schedule[index - 14u] ^ schedule[index - 16u],
+    schedule_data[index] =
+        rotate_left(schedule_data[index - 3u] ^ schedule_data[index - 8u] ^
+                        schedule_data[index - 14u] ^ schedule_data[index - 16u],
                     1u);
   }
 
   auto working = state;
+  auto *working_data = working.data();
 
   // Compression function (RFC 3174 Section 6.1 step d), with the round
   // constants of RFC 3174 Section 5
@@ -66,31 +68,37 @@ inline auto sha1_process_block(const unsigned char *block,
     std::uint32_t function_value;
     std::uint32_t round_constant;
     if (round_index < 20u) {
-      function_value = choice(working[1], working[2], working[3]);
+      function_value =
+          choice(working_data[1], working_data[2], working_data[3]);
       round_constant = 0x5a827999U;
     } else if (round_index < 40u) {
-      function_value = parity(working[1], working[2], working[3]);
+      function_value =
+          parity(working_data[1], working_data[2], working_data[3]);
       round_constant = 0x6ed9eba1U;
     } else if (round_index < 60u) {
-      function_value = majority(working[1], working[2], working[3]);
+      function_value =
+          majority(working_data[1], working_data[2], working_data[3]);
       round_constant = 0x8f1bbcdcU;
     } else {
-      function_value = parity(working[1], working[2], working[3]);
+      function_value =
+          parity(working_data[1], working_data[2], working_data[3]);
       round_constant = 0xca62c1d6U;
     }
 
-    const auto temporary = rotate_left(working[0], 5u) + function_value +
-                           working[4] + schedule[round_index] + round_constant;
+    const auto temporary = rotate_left(working_data[0], 5u) + function_value +
+                           working_data[4] + schedule_data[round_index] +
+                           round_constant;
 
-    working[4] = working[3];
-    working[3] = working[2];
-    working[2] = rotate_left(working[1], 30u);
-    working[1] = working[0];
-    working[0] = temporary;
+    working_data[4] = working_data[3];
+    working_data[3] = working_data[2];
+    working_data[2] = rotate_left(working_data[1], 30u);
+    working_data[1] = working_data[0];
+    working_data[0] = temporary;
   }
 
+  auto *state_data = state.data();
   for (std::uint64_t index = 0u; index < 5u; ++index) {
-    state[index] += working[index];
+    state_data[index] += working_data[index];
   }
 }
 
diff --git a/vendor/core/src/core/crypto/crypto_sha256_other.h b/vendor/core/src/core/crypto/crypto_sha256_other.h
index 1238baa5..dc28a911 100644
--- a/vendor/core/src/core/crypto/crypto_sha256_other.h
+++ b/vendor/core/src/core/crypto/crypto_sha256_other.h
@@ -12,36 +12,30 @@
 
 namespace sourcemeta::core {
 
-// The count must be between 1 and 31, as the complementary shift is
-// undefined otherwise
-inline constexpr auto sha256_rotate_right(std::uint32_t value,
-                                          std::uint64_t count) noexcept
-    -> std::uint32_t {
-  return (value >> count) | (value << (32u - count));
-}
-
-// FIPS 180-4 Section 4.1.2 logical functions
+// FIPS 180-4 Section 4.1.2 logical functions. Each right rotation is written
+// out as a shift pair rather than through a helper, so that an unoptimized
+// build does not pay a function call per rotation
 inline constexpr auto sha256_big_sigma_0(std::uint32_t value) noexcept
     -> std::uint32_t {
-  return sha256_rotate_right(value, 2u) ^ sha256_rotate_right(value, 13u) ^
-         sha256_rotate_right(value, 22u);
+  return ((value >> 2u) | (value << 30u)) ^ ((value >> 13u) | (value << 19u)) ^
+         ((value >> 22u) | (value << 10u));
 }
 
 inline constexpr auto sha256_big_sigma_1(std::uint32_t value) noexcept
     -> std::uint32_t {
-  return sha256_rotate_right(value, 6u) ^ sha256_rotate_right(value, 11u) ^
-         sha256_rotate_right(value, 25u);
+  return ((value >> 6u) | (value << 26u)) ^ ((value >> 11u) | (value << 21u)) ^
+         ((value >> 25u) | (value << 7u));
 }
 
 inline constexpr auto sha256_small_sigma_0(std::uint32_t value) noexcept
     -> std::uint32_t {
-  return sha256_rotate_right(value, 7u) ^ sha256_rotate_right(value, 18u) ^
+  return ((value >> 7u) | (value << 25u)) ^ ((value >> 18u) | (value << 14u)) ^
          (value >> 3u);
 }
 
 inline constexpr auto sha256_small_sigma_1(std::uint32_t value) noexcept
     -> std::uint32_t {
-  return sha256_rotate_right(value, 17u) ^ sha256_rotate_right(value, 19u) ^
+  return ((value >> 17u) | (value << 15u)) ^ ((value >> 19u) | (value << 13u)) ^
          (value >> 10u);
 }
 
@@ -79,9 +73,10 @@ inline auto sha256_process_block(const std::uint8_t *block,
 
   // Decode 16 big-endian 32-bit words from the block
   std::array<std::uint32_t, 64> schedule;
+  auto *schedule_data = schedule.data();
   for (std::uint64_t word_index = 0; word_index < 16u; ++word_index) {
     const std::uint64_t byte_index = word_index * 4u;
-    schedule[word_index] =
+    schedule_data[word_index] =
         (static_cast<std::uint32_t>(block[byte_index]) << 24u) |
         (static_cast<std::uint32_t>(block[byte_index + 1u]) << 16u) |
         (static_cast<std::uint32_t>(block[byte_index + 2u]) << 8u) |
@@ -90,35 +85,39 @@ inline auto sha256_process_block(const std::uint8_t *block,
 
   // Extend the message schedule (FIPS 180-4 Section 6.2.2 step 1)
   for (std::uint64_t index = 16u; index < 64u; ++index) {
-    schedule[index] =
-        sha256_small_sigma_1(schedule[index - 2u]) + schedule[index - 7u] +
-        sha256_small_sigma_0(schedule[index - 15u]) + schedule[index - 16u];
+    schedule_data[index] = sha256_small_sigma_1(schedule_data[index - 2u]) +
+                           schedule_data[index - 7u] +
+                           sha256_small_sigma_0(schedule_data[index - 15u]) +
+                           schedule_data[index - 16u];
   }
 
   auto working = state;
+  auto *working_data = working.data();
+  const auto *constants_data = round_constants.data();
 
   // Compression function (FIPS 180-4 Section 6.2.2 step 3)
   for (std::uint64_t round_index = 0u; round_index < 64u; ++round_index) {
-    const auto temporary_1 = working[7] + sha256_big_sigma_1(working[4]) +
-                             sha256_choice(working[4], working[5], working[6]) +
-                             round_constants[round_index] +
-                             schedule[round_index];
+    const auto temporary_1 =
+        working_data[7] + sha256_big_sigma_1(working_data[4]) +
+        sha256_choice(working_data[4], working_data[5], working_data[6]) +
+        constants_data[round_index] + schedule_data[round_index];
     const auto temporary_2 =
-        sha256_big_sigma_0(working[0]) +
-        sha256_majority(working[0], working[1], working[2]);
-
-    working[7] = working[6];
-    working[6] = working[5];
-    working[5] = working[4];
-    working[4] = working[3] + temporary_1;
-    working[3] = working[2];
-    working[2] = working[1];
-    working[1] = working[0];
-    working[0] = temporary_1 + temporary_2;
+        sha256_big_sigma_0(working_data[0]) +
+        sha256_majority(working_data[0], working_data[1], working_data[2]);
+
+    working_data[7] = working_data[6];
+    working_data[6] = working_data[5];
+    working_data[5] = working_data[4];
+    working_data[4] = working_data[3] + temporary_1;
+    working_data[3] = working_data[2];
+    working_data[2] = working_data[1];
+    working_data[1] = working_data[0];
+    working_data[0] = temporary_1 + temporary_2;
   }
 
+  auto *state_data = state.data();
   for (std::uint64_t index = 0u; index < 8u; ++index) {
-    state[index] += working[index];
+    state_data[index] += working_data[index];
   }
 }
 
diff --git a/vendor/core/src/core/crypto/crypto_sha2_64.h b/vendor/core/src/core/crypto/crypto_sha2_64.h
index 78ebff3b..3da417ca 100644
--- a/vendor/core/src/core/crypto/crypto_sha2_64.h
+++ b/vendor/core/src/core/crypto/crypto_sha2_64.h
@@ -12,36 +12,30 @@
 
 namespace sourcemeta::core {
 
-// The count must be between 1 and 63, as the complementary shift is
-// undefined otherwise
-inline constexpr auto sha2_64_rotate_right(std::uint64_t value,
-                                           std::uint64_t count) noexcept
-    -> std::uint64_t {
-  return (value >> count) | (value << (64u - count));
-}
-
-// FIPS 180-4 Section 4.1.3 logical functions
+// FIPS 180-4 Section 4.1.3 logical functions. Each right rotation is written
+// out as a shift pair rather than through a helper, so that an unoptimized
+// build does not pay a function call per rotation
 inline constexpr auto sha2_64_big_sigma_0(std::uint64_t value) noexcept
     -> std::uint64_t {
-  return sha2_64_rotate_right(value, 28u) ^ sha2_64_rotate_right(value, 34u) ^
-         sha2_64_rotate_right(value, 39u);
+  return ((value >> 28u) | (value << 36u)) ^ ((value >> 34u) | (value << 30u)) ^
+         ((value >> 39u) | (value << 25u));
 }
 
 inline constexpr auto sha2_64_big_sigma_1(std::uint64_t value) noexcept
     -> std::uint64_t {
-  return sha2_64_rotate_right(value, 14u) ^ sha2_64_rotate_right(value, 18u) ^
-         sha2_64_rotate_right(value, 41u);
+  return ((value >> 14u) | (value << 50u)) ^ ((value >> 18u) | (value << 46u)) ^
+         ((value >> 41u) | (value << 23u));
 }
 
 inline constexpr auto sha2_64_small_sigma_0(std::uint64_t value) noexcept
     -> std::uint64_t {
-  return sha2_64_rotate_right(value, 1u) ^ sha2_64_rotate_right(value, 8u) ^
+  return ((value >> 1u) | (value << 63u)) ^ ((value >> 8u) | (value << 56u)) ^
          (value >> 7u);
 }
 
 inline constexpr auto sha2_64_small_sigma_1(std::uint64_t value) noexcept
     -> std::uint64_t {
-  return sha2_64_rotate_right(value, 19u) ^ sha2_64_rotate_right(value, 61u) ^
+  return ((value >> 19u) | (value << 45u)) ^ ((value >> 61u) | (value << 3u)) ^
          (value >> 6u);
 }
 
@@ -94,9 +88,10 @@ inline auto sha2_64_process_block(const std::uint8_t *block,
 
   // Decode 16 big-endian 64-bit words from the block
   std::array<std::uint64_t, 80> schedule;
+  auto *schedule_data = schedule.data();
   for (std::uint64_t word_index = 0; word_index < 16u; ++word_index) {
     const std::uint64_t byte_index = word_index * 8u;
-    schedule[word_index] =
+    schedule_data[word_index] =
         (static_cast<std::uint64_t>(block[byte_index]) << 56u) |
         (static_cast<std::uint64_t>(block[byte_index + 1u]) << 48u) |
         (static_cast<std::uint64_t>(block[byte_index + 2u]) << 40u) |
@@ -109,35 +104,39 @@ inline auto sha2_64_process_block(const std::uint8_t *block,
 
   // Extend the message schedule (FIPS 180-4 Section 6.4.2 step 1)
   for (std::uint64_t index = 16u; index < 80u; ++index) {
-    schedule[index] =
-        sha2_64_small_sigma_1(schedule[index - 2u]) + schedule[index - 7u] +
-        sha2_64_small_sigma_0(schedule[index - 15u]) + schedule[index - 16u];
+    schedule_data[index] = sha2_64_small_sigma_1(schedule_data[index - 2u]) +
+                           schedule_data[index - 7u] +
+                           sha2_64_small_sigma_0(schedule_data[index - 15u]) +
+                           schedule_data[index - 16u];
   }
 
   auto working = state;
+  auto *working_data = working.data();
+  const auto *constants_data = round_constants.data();
 
   // Compression function (FIPS 180-4 Section 6.4.2 step 3)
   for (std::uint64_t round_index = 0u; round_index < 80u; ++round_index) {
     const auto temporary_1 =
-        working[7] + sha2_64_big_sigma_1(working[4]) +
-        sha2_64_choice(working[4], working[5], working[6]) +
-        round_constants[round_index] + schedule[round_index];
+        working_data[7] + sha2_64_big_sigma_1(working_data[4]) +
+        sha2_64_choice(working_data[4], working_data[5], working_data[6]) +
+        constants_data[round_index] + schedule_data[round_index];
     const auto temporary_2 =
-        sha2_64_big_sigma_0(working[0]) +
-        sha2_64_majority(working[0], working[1], working[2]);
-
-    working[7] = working[6];
-    working[6] = working[5];
-    working[5] = working[4];
-    working[4] = working[3] + temporary_1;
-    working[3] = working[2];
-    working[2] = working[1];
-    working[1] = working[0];
-    working[0] = temporary_1 + temporary_2;
+        sha2_64_big_sigma_0(working_data[0]) +
+        sha2_64_majority(working_data[0], working_data[1], working_data[2]);
+
+    working_data[7] = working_data[6];
+    working_data[6] = working_data[5];
+    working_data[5] = working_data[4];
+    working_data[4] = working_data[3] + temporary_1;
+    working_data[3] = working_data[2];
+    working_data[2] = working_data[1];
+    working_data[1] = working_data[0];
+    working_data[0] = temporary_1 + temporary_2;
   }
 
+  auto *state_data = state.data();
   for (std::uint64_t index = 0u; index < 8u; ++index) {
-    state[index] += working[index];
+    state_data[index] += working_data[index];
   }
 }
 
diff --git a/vendor/core/src/core/crypto/crypto_shake256.h b/vendor/core/src/core/crypto/crypto_shake256.h
index 09b9e3d5..b3e7e7bc 100644
--- a/vendor/core/src/core/crypto/crypto_shake256.h
+++ b/vendor/core/src/core/crypto/crypto_shake256.h
@@ -40,47 +40,56 @@ constexpr auto keccak_rotate_left(const std::uint64_t value,
 
 inline auto keccak_permute(std::array<std::uint64_t, 25> &state) noexcept
     -> void {
+  auto *state_data{state.data()};
+  const auto *pi_lanes{KECCAK_PI_LANES.data()};
+  const auto *rho_offsets{KECCAK_RHO_OFFSETS.data()};
+  const auto *round_constants{KECCAK_ROUND_CONSTANTS.data()};
   for (std::size_t round = 0; round < 24; ++round) {
     // Theta
     std::array<std::uint64_t, 5> column_parity{};
+    auto *column_parity_data{column_parity.data()};
     for (std::size_t column = 0; column < 5; ++column) {
-      column_parity[column] = state[column] ^ state[column + 5] ^
-                              state[column + 10] ^ state[column + 15] ^
-                              state[column + 20];
+      column_parity_data[column] = state_data[column] ^ state_data[column + 5] ^
+                                   state_data[column + 10] ^
+                                   state_data[column + 15] ^
+                                   state_data[column + 20];
     }
 
     for (std::size_t column = 0; column < 5; ++column) {
-      const auto delta{column_parity[(column + 4) % 5] ^
-                       keccak_rotate_left(column_parity[(column + 1) % 5], 1)};
+      const auto delta{
+          column_parity_data[(column + 4) % 5] ^
+          keccak_rotate_left(column_parity_data[(column + 1) % 5], 1)};
       for (std::size_t row = 0; row < 25; row += 5) {
-        state[row + column] ^= delta;
+        state_data[row + column] ^= delta;
       }
     }
 
     // Rho and pi
-    auto current{state[1]};
+    auto current{state_data[1]};
     for (std::size_t index = 0; index < 24; ++index) {
-      const auto lane{KECCAK_PI_LANES[index]};
-      const auto moved{state[lane]};
-      state[lane] = keccak_rotate_left(current, KECCAK_RHO_OFFSETS[index]);
+      const auto lane{pi_lanes[index]};
+      const auto moved{state_data[lane]};
+      state_data[lane] = keccak_rotate_left(current, rho_offsets[index]);
       current = moved;
     }
 
     // Chi
     for (std::size_t row = 0; row < 25; row += 5) {
       std::array<std::uint64_t, 5> plane{};
+      auto *plane_data{plane.data()};
       for (std::size_t column = 0; column < 5; ++column) {
-        plane[column] = state[row + column];
+        plane_data[column] = state_data[row + column];
       }
 
       for (std::size_t column = 0; column < 5; ++column) {
-        state[row + column] = plane[column] ^ (~plane[(column + 1) % 5] &
-                                               plane[(column + 2) % 5]);
+        state_data[row + column] =
+            plane_data[column] ^
+            (~plane_data[(column + 1) % 5] & plane_data[(column + 2) % 5]);
       }
     }
 
     // Iota
-    state[0] ^= KECCAK_ROUND_CONSTANTS[round];
+    state_data[0] ^= round_constants[round];
   }
 }
 
@@ -90,10 +99,11 @@ inline auto shake256(const std::string_view input,
   // The bitrate is 1600 - 2 * 256 = 1088 bits, that is 136 octets
   constexpr std::size_t RATE{136};
   std::array<std::uint64_t, 25> state{};
+  auto *state_data{state.data()};
 
   std::size_t pointer{0};
   for (const auto character : input) {
-    state[pointer / 8] ^=
+    state_data[pointer / 8] ^=
         static_cast<std::uint64_t>(static_cast<std::uint8_t>(character))
         << (8 * (pointer % 8));
     pointer += 1;
@@ -115,7 +125,8 @@ inline auto shake256(const std::string_view input,
   std::size_t squeeze_pointer{0};
   while (output.size() < output_length) {
     output.push_back(static_cast<char>(
-        (state[squeeze_pointer / 8] >> (8 * (squeeze_pointer % 8))) & 0xffU));
+        (state_data[squeeze_pointer / 8] >> (8 * (squeeze_pointer % 8))) &
+        0xffU));
     squeeze_pointer += 1;
     if (squeeze_pointer == RATE) {
       keccak_permute(state);
diff --git a/vendor/core/src/core/crypto/crypto_sign_apple.cc b/vendor/core/src/core/crypto/crypto_sign_apple.cc
index 67e26b7f..887db821 100644
--- a/vendor/core/src/core/crypto/crypto_sign_apple.cc
+++ b/vendor/core/src/core/crypto/crypto_sign_apple.cc
@@ -7,6 +7,7 @@
 #include "crypto_eddsa_apple.h"
 #include "crypto_helpers.h"
 #include "crypto_pkcs8.h"
+#include "crypto_system.h"
 
 #include <CoreFoundation/CoreFoundation.h> // CF*, kCF*
 #include <Security/Security.h>             // Sec*, kSec*
diff --git a/vendor/core/src/core/crypto/crypto_sign_other.cc b/vendor/core/src/core/crypto/crypto_sign_other.cc
index 19d6cf8c..049764db 100644
--- a/vendor/core/src/core/crypto/crypto_sign_other.cc
+++ b/vendor/core/src/core/crypto/crypto_sign_other.cc
@@ -9,6 +9,7 @@
 #include "crypto_other.h"
 #include "crypto_pkcs8.h"
 #include "crypto_random.h"
+#include "crypto_rsa_other.h"
 
 #include <array>       // std::array
 #include <cassert>     // assert
@@ -194,8 +195,8 @@ auto hmac(const SignatureHashFunction hash, const std::string_view key,
 // RFC 6979 Section 2.3.2 bits2int, which is also the FIPS 186-4 Section 6.4
 // truncation of a bit string to the leftmost order-length bits
 auto bits2int(const std::string_view bits, const std::size_t order_bits)
-    -> Bignum {
-  auto value{bignum_from_bytes(bits)};
+    -> CurveBignum {
+  auto value{bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(bits)};
   const auto bit_length{bits.size() * 8};
   if (bit_length > order_bits) {
     value = bignum_shift_right(value, bit_length - order_bits);
@@ -206,7 +207,7 @@ auto bits2int(const std::string_view bits, const std::size_t order_bits)
 
 // RFC 6979 Section 2.3.4 bits2octets, reducing the truncated hash modulo the
 // order and encoding it to the fixed octet width
-auto bits2octets(const std::string_view bits, const Bignum &order,
+auto bits2octets(const std::string_view bits, const CurveBignum &order,
                  const std::size_t order_bits, const std::size_t order_bytes)
     -> std::string {
   auto value{bits2int(bits, order_bits)};
@@ -214,25 +215,19 @@ auto bits2octets(const std::string_view bits, const Bignum &order,
   return bignum_to_bytes(value, order_bytes);
 }
 
-auto sign_rsa(const std::string_view modulus,
-              const std::string_view private_exponent,
+auto sign_rsa(const PrivateKey::Internal &key,
               const std::string_view encoded_message) -> std::string {
-  // The exponent is the secret private key, so the exponentiation runs in
-  // constant time; the exponent copy it consumes is wiped before returning
-  const auto context{barrett_context(bignum_from_bytes(modulus))};
-  auto exponent{bignum_from_bytes(private_exponent)};
-  const SecureBignumScope exponent_scope{exponent};
   auto representative{
-      bignum_mod_exp_ct(bignum_from_bytes(encoded_message), exponent, context)};
+      rsa_private_operation(key, bignum_from_bytes(encoded_message))};
   bignum_normalize(representative);
-  return bignum_to_bytes(representative, modulus.size());
+  return bignum_to_bytes(representative, key.modulus.size());
 }
 
 // The signature for one nonce candidate (FIPS 186-4 Section 6.4.1), returning
 // no value when the candidate must be rejected and a fresh one drawn
-auto ecdsa_signature_for_nonce(const Bignum &nonce,
-                               const Bignum &digest_integer,
-                               const Bignum &private_scalar,
+auto ecdsa_signature_for_nonce(const CurveBignum &nonce,
+                               const CurveBignum &digest_integer,
+                               const CurveBignum &private_scalar,
                                const JacobianPoint &generator,
                                const EllipticCurveParameters &parameters,
                                const std::size_t field_bytes)
@@ -293,11 +288,11 @@ auto sign_ecdsa(const EllipticCurve curve, const SignatureHashFunction hash,
   const auto order_bytes{(order_bits + 7) / 8};
   const auto digest{digest_message(hash, message)};
   const auto digest_integer{bits2int(digest, order_bits)};
-  auto private_scalar{bignum_from_bytes(scalar)};
+  auto private_scalar{bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(scalar)};
   const SecureBignumScope private_scalar_scope{private_scalar};
   const JacobianPoint generator{.x = parameters.generator_x,
                                 .y = parameters.generator_y,
-                                .z = bignum_from_u64(1)};
+                                .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
 
   auto private_octets{bignum_to_bytes(private_scalar, order_bytes)};
   const SecureStringScope private_octets_scope{private_octets};
@@ -361,8 +356,8 @@ auto ec_public_from_scalar(const EllipticCurve curve,
   const auto parameters{to_curve_parameters(curve)};
   const JacobianPoint generator{.x = parameters.generator_x,
                                 .y = parameters.generator_y,
-                                .z = bignum_from_u64(1)};
-  auto scalar_number{bignum_from_bytes(scalar)};
+                                .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
+  auto scalar_number{bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(scalar)};
   const SecureBignumScope scalar_scope{scalar_number};
   // The complete-formula ladder returns a projective point, whose affine
   // coordinates are X / Z and Y / Z, not the Jacobian X / Z^2 and Y / Z^3, so
@@ -370,7 +365,7 @@ auto ec_public_from_scalar(const EllipticCurve curve,
   // path rather than the Jacobian point_to_affine
   const auto product{point_scalar_multiply_constant_time(
       scalar_number, generator, parameters)};
-  const auto field{barrett_context(parameters.prime)};
+  const auto field{curve_field_context(parameters)};
   const auto z_inverse{field_inverse_ct(product.z, field)};
   auto coordinate_x{field_mod_multiply_ct(product.x, z_inverse, field)};
   auto coordinate_y{field_mod_multiply_ct(product.y, z_inverse, field)};
@@ -380,6 +375,51 @@ auto ec_public_from_scalar(const EllipticCurve curve,
           bignum_to_bytes(coordinate_y, parameters.field_bytes)};
 }
 
+// The CRT components of a two-prime RSAPrivateKey (RFC 8017 Appendix A.1.2),
+// viewing the canonical magnitudes that follow the private exponent
+struct RSACRTComponents {
+  std::string_view prime1;
+  std::string_view prime2;
+  std::string_view exponent1;
+  std::string_view exponent2;
+  std::string_view coefficient;
+};
+
+// Read the CRT components that follow the private exponent, returning no value
+// for the multi-prime form (version one), whose private operation needs the
+// further primes, or for components that are not canonical non-negative DER
+// INTEGERs within the key size limit
+auto read_rsa_crt_components(const std::string_view version,
+                             std::string_view rest)
+    -> std::optional<RSACRTComponents> {
+  if (version.size() != 1 || version.front() != '\x00') {
+    return std::nullopt;
+  }
+
+  std::array<std::string_view, 5> components;
+  for (auto &component : components) {
+    const auto element{der_read(rest)};
+    if (!element.has_value() || element->tag != 0x02) {
+      return std::nullopt;
+    }
+
+    const auto magnitude{der_unsigned_integer(element->content)};
+    if (!magnitude.has_value() || magnitude->empty() ||
+        magnitude->size() > MAXIMUM_KEY_BYTES) {
+      return std::nullopt;
+    }
+
+    component = magnitude.value();
+    rest = element->rest;
+  }
+
+  return RSACRTComponents{.prime1 = components[0],
+                          .prime2 = components[1],
+                          .exponent1 = components[2],
+                          .exponent2 = components[3],
+                          .coefficient = components[4]};
+}
+
 } // namespace
 
 PrivateKey::PrivateKey(Internal *internal) noexcept : internal_{internal} {}
@@ -387,6 +427,11 @@ PrivateKey::PrivateKey(Internal *internal) noexcept : internal_{internal} {}
 PrivateKey::~PrivateKey() {
   if (internal_ != nullptr) {
     secure_zero(internal_->private_exponent);
+    secure_zero(internal_->prime1);
+    secure_zero(internal_->prime2);
+    secure_zero(internal_->exponent1);
+    secure_zero(internal_->exponent2);
+    secure_zero(internal_->coefficient);
     secure_zero(internal_->scalar);
     secure_zero(internal_->edwards_seed);
     delete internal_;
@@ -402,6 +447,11 @@ auto PrivateKey::operator=(PrivateKey &&other) noexcept -> PrivateKey & {
   if (this != &other) {
     if (internal_ != nullptr) {
       secure_zero(internal_->private_exponent);
+      secure_zero(internal_->prime1);
+      secure_zero(internal_->prime2);
+      secure_zero(internal_->exponent1);
+      secure_zero(internal_->exponent2);
+      secure_zero(internal_->coefficient);
       secure_zero(internal_->scalar);
       secure_zero(internal_->edwards_seed);
       delete internal_;
@@ -480,11 +530,24 @@ auto make_private_key(const std::string_view pem) -> std::optional<PrivateKey> {
         return std::nullopt;
       }
 
+      // RFC 8017 Appendix A.1.2: the two-prime form carries the CRT components
+      // after the private exponent, which the private operation uses to take
+      // the cheaper path of RFC 8017 Section 5.1.2 step 2.b
+      const auto crt{
+          read_rsa_crt_components(version->content, private_exponent->rest)};
       return PrivateKey{new PrivateKey::Internal{
           .kind = PrivateKey::Type::RSA,
           .modulus = std::string{modulus_value.value()},
           .public_exponent = std::string{public_exponent_value.value()},
           .private_exponent = std::string{private_exponent_value.value()},
+          .prime1 = crt.has_value() ? std::string{crt->prime1} : std::string{},
+          .prime2 = crt.has_value() ? std::string{crt->prime2} : std::string{},
+          .exponent1 =
+              crt.has_value() ? std::string{crt->exponent1} : std::string{},
+          .exponent2 =
+              crt.has_value() ? std::string{crt->exponent2} : std::string{},
+          .coefficient =
+              crt.has_value() ? std::string{crt->coefficient} : std::string{},
           .scalar = {},
           .elliptic_curve = {},
           .edwards_seed = {},
@@ -531,6 +594,11 @@ auto make_private_key(const std::string_view pem) -> std::optional<PrivateKey> {
                                    .modulus = {},
                                    .public_exponent = {},
                                    .private_exponent = {},
+                                   .prime1 = {},
+                                   .prime2 = {},
+                                   .exponent1 = {},
+                                   .exponent2 = {},
+                                   .coefficient = {},
                                    .scalar = padded_scalar,
                                    .elliptic_curve = parsed->curve,
                                    .edwards_seed = {},
@@ -551,6 +619,11 @@ auto make_private_key(const std::string_view pem) -> std::optional<PrivateKey> {
                                    .modulus = {},
                                    .public_exponent = {},
                                    .private_exponent = {},
+                                   .prime1 = {},
+                                   .prime2 = {},
+                                   .exponent1 = {},
+                                   .exponent2 = {},
+                                   .coefficient = {},
                                    .scalar = {},
                                    .elliptic_curve = {},
                                    .edwards_seed = std::string{seed->content},
@@ -598,6 +671,11 @@ auto make_ec_private_key(const EllipticCurve curve,
                                .modulus = {},
                                .public_exponent = {},
                                .private_exponent = {},
+                               .prime1 = {},
+                               .prime2 = {},
+                               .exponent1 = {},
+                               .exponent2 = {},
+                               .coefficient = {},
                                .scalar = std::string{padded_scalar},
                                .elliptic_curve = curve,
                                .edwards_seed = {},
@@ -617,7 +695,7 @@ auto generate_ec_private_key(const EllipticCurve curve)
   // retry rate low even for P-521, whose order fills only 521 of its 528 bits
   std::string scalar(width, '\x00');
   const SecureStringScope scalar_scope{scalar};
-  Bignum scalar_number;
+  CurveBignum scalar_number;
   const SecureBignumScope scalar_number_scope{scalar_number};
   do {
     try {
@@ -630,7 +708,7 @@ auto generate_ec_private_key(const EllipticCurve curve)
     scalar[0] =
         static_cast<char>(static_cast<std::uint8_t>(scalar[0]) &
                           static_cast<std::uint8_t>(0xffu >> excess_bits));
-    scalar_number = bignum_from_bytes(scalar);
+    scalar_number = bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(scalar);
   } while (bignum_is_zero(scalar_number) ||
            bignum_compare(scalar_number, parameters.order) >= 0);
 
@@ -640,6 +718,11 @@ auto generate_ec_private_key(const EllipticCurve curve)
                                .modulus = {},
                                .public_exponent = {},
                                .private_exponent = {},
+                               .prime1 = {},
+                               .prime2 = {},
+                               .exponent1 = {},
+                               .exponent2 = {},
+                               .coefficient = {},
                                .scalar = scalar,
                                .elliptic_curve = curve,
                                .edwards_seed = {},
@@ -659,6 +742,11 @@ auto make_edwards_private_key(const EdwardsCurve curve,
                                              .modulus = {},
                                              .public_exponent = {},
                                              .private_exponent = {},
+                                             .prime1 = {},
+                                             .prime2 = {},
+                                             .exponent1 = {},
+                                             .exponent2 = {},
+                                             .coefficient = {},
                                              .scalar = {},
                                              .elliptic_curve = {},
                                              .edwards_seed = std::string{seed},
@@ -687,8 +775,7 @@ auto rsassa_pkcs1_v15_sign(const PrivateKey &key,
     return std::nullopt;
   }
 
-  return sign_rsa(internal->modulus, internal->private_exponent,
-                  encoded.value());
+  return sign_rsa(*internal, encoded.value());
 }
 
 auto rsassa_pss_sign(const PrivateKey &key, const SignatureHashFunction hash,
@@ -706,8 +793,7 @@ auto rsassa_pss_sign(const PrivateKey &key, const SignatureHashFunction hash,
     return std::nullopt;
   }
 
-  return sign_rsa(internal->modulus, internal->private_exponent,
-                  encoded.value());
+  return sign_rsa(*internal, encoded.value());
 }
 
 auto ecdsa_sign(const PrivateKey &key, const SignatureHashFunction hash,
diff --git a/vendor/core/src/core/crypto/crypto_sign_windows.cc b/vendor/core/src/core/crypto/crypto_sign_windows.cc
index eee6cafe..a6fe5b67 100644
--- a/vendor/core/src/core/crypto/crypto_sign_windows.cc
+++ b/vendor/core/src/core/crypto/crypto_sign_windows.cc
@@ -4,6 +4,7 @@
 #include "crypto_eddsa.h"
 #include "crypto_helpers.h"
 #include "crypto_pkcs8.h"
+#include "crypto_system.h"
 
 #define WIN32_LEAN_AND_MEAN
 #ifndef NOMINMAX
diff --git a/vendor/core/src/core/crypto/crypto_system.h b/vendor/core/src/core/crypto/crypto_system.h
new file mode 100644
index 00000000..e36e4971
--- /dev/null
+++ b/vendor/core/src/core/crypto/crypto_system.h
@@ -0,0 +1,120 @@
+#ifndef SOURCEMETA_CORE_CRYPTO_SYSTEM_H_
+#define SOURCEMETA_CORE_CRYPTO_SYSTEM_H_
+
+// Primitives that only the backends built on a system cryptography library
+// reach for, kept apart from the ones that the reference backend shares
+
+#include <sourcemeta/core/crypto_verify.h>
+#include <sourcemeta/core/text.h>
+
+#include "crypto_der.h"
+#include "crypto_helpers.h"
+
+#include <cstddef>     // std::size_t
+#include <optional>    // std::optional, std::nullopt
+#include <string>      // std::string
+#include <string_view> // std::string_view
+#include <utility>     // std::pair, std::unreachable
+
+namespace sourcemeta::core {
+
+// Whether a signature is a well-formed representative for the modulus. RFC 8017
+// Section 8.2.2 step 1 and Section 8.1.2 step 1: "If the length of the
+// signature S is not k octets, output "invalid signature" and stop". The length
+// is checked because the range comparison reads both operands as bare integers,
+// so a signature that merely dropped a leading zero octet would denote the same
+// value and verify, giving a second encoding of one signature. Section 5.2.2
+// then requires the range check, so that an unreduced signature, which an
+// attacker forges by adding the modulus without changing the modular
+// exponentiation result, is rejected. The modulus is stripped for the length so
+// that a stored ASN.1 sign octet cannot inflate k
+inline auto rsa_signature_acceptable(const std::string_view signature,
+                                     const std::string_view modulus) noexcept
+    -> bool {
+  return signature.size() == strip_left(modulus, '\x00').size() &&
+         octets_below(signature, modulus);
+}
+
+// The order bit length of each curve, which the platform key generators take as
+// the requested key size. It is not the field width in bits, since P-521 has a
+// 521-bit order that does not fill its 66 octets
+inline auto curve_bit_length(const EllipticCurve curve) noexcept
+    -> std::size_t {
+  switch (curve) {
+    case EllipticCurve::P256:
+      return 256;
+    case EllipticCurve::P384:
+      return 384;
+    case EllipticCurve::P521:
+      return 521;
+  }
+
+  std::unreachable();
+}
+
+// Identify a curve from its field width, the inverse of the mapping from a
+// curve to that width, so a backend that reports a key only by coordinate size
+// resolves it the same way
+inline auto ec_curve_from_field_bytes(const std::size_t field_bytes) noexcept
+    -> std::optional<EllipticCurve> {
+  switch (field_bytes) {
+    case 32:
+      return EllipticCurve::P256;
+    case 48:
+      return EllipticCurve::P384;
+    case 66:
+      return EllipticCurve::P521;
+    default:
+      return std::nullopt;
+  }
+}
+
+// The signature octet length is fixed per curve (RFC 8032 Section 5.1.6)
+inline auto eddsa_signature_bytes(const EdwardsCurve curve) noexcept
+    -> std::size_t {
+  switch (curve) {
+    case EdwardsCurve::Ed25519:
+      return 64;
+    case EdwardsCurve::Ed448:
+      return 114;
+  }
+
+  std::unreachable();
+}
+
+// Read the modulus and public exponent from a PKCS#1 RSAPublicKey structure
+// (RFC 8017 Appendix A.1.1), a DER SEQUENCE of exactly the two integers, each
+// returned as its minimal big-endian magnitude. Trailing bytes at either level
+// are rejected so the input parses as exactly that structure
+inline auto der_read_rsa_public_key(const std::string_view der)
+    -> std::optional<std::pair<std::string, std::string>> {
+  const auto sequence{der_read(der)};
+  if (!sequence.has_value() || sequence->tag != 0x30 ||
+      !sequence->rest.empty()) {
+    return std::nullopt;
+  }
+
+  const auto modulus{der_read(sequence->content)};
+  if (!modulus.has_value() || modulus->tag != 0x02) {
+    return std::nullopt;
+  }
+
+  const auto exponent{der_read(modulus->rest)};
+  if (!exponent.has_value() || exponent->tag != 0x02 ||
+      !exponent->rest.empty()) {
+    return std::nullopt;
+  }
+
+  const auto modulus_value{der_unsigned_integer(modulus->content)};
+  const auto exponent_value{der_unsigned_integer(exponent->content)};
+  if (!modulus_value.has_value() || !exponent_value.has_value()) {
+    return std::nullopt;
+  }
+
+  return std::pair{std::string{modulus_value.value()},
+                   std::string{exponent_value.value()}};
+}
+
+} // namespace sourcemeta::core
+
+#endif
diff --git a/vendor/core/src/core/crypto/crypto_verify_apple.cc b/vendor/core/src/core/crypto/crypto_verify_apple.cc
index 4320a39c..44d71be8 100644
--- a/vendor/core/src/core/crypto/crypto_verify_apple.cc
+++ b/vendor/core/src/core/crypto/crypto_verify_apple.cc
@@ -6,6 +6,7 @@
 #include "crypto_eddsa.h"
 #include "crypto_eddsa_apple.h"
 #include "crypto_helpers.h"
+#include "crypto_system.h"
 
 #include <CoreFoundation/CoreFoundation.h> // CF*, kCF*
 #include <Security/Security.h>             // Sec*, kSec*
diff --git a/vendor/core/src/core/crypto/crypto_verify_openssl.cc b/vendor/core/src/core/crypto/crypto_verify_openssl.cc
index a3ac2088..bd71e919 100644
--- a/vendor/core/src/core/crypto/crypto_verify_openssl.cc
+++ b/vendor/core/src/core/crypto/crypto_verify_openssl.cc
@@ -3,6 +3,7 @@
 
 #include "crypto_helpers.h"
 #include "crypto_openssl.h"
+#include "crypto_system.h"
 
 #include <openssl/bn.h>          // BN_*
 #include <openssl/core_names.h>  // OSSL_PKEY_PARAM_*
diff --git a/vendor/core/src/core/crypto/crypto_verify_other.cc b/vendor/core/src/core/crypto/crypto_verify_other.cc
index b9a8f020..618fd1f2 100644
--- a/vendor/core/src/core/crypto/crypto_verify_other.cc
+++ b/vendor/core/src/core/crypto/crypto_verify_other.cc
@@ -183,9 +183,9 @@ auto to_curve_parameters(const EllipticCurve curve) -> EllipticCurveParameters {
 // of the message digest, truncated to the bit length of the order
 auto digest_to_integer(const SignatureHashFunction hash,
                        const std::string_view message,
-                       const std::size_t order_bits) -> Bignum {
+                       const std::size_t order_bits) -> CurveBignum {
   const auto digest{digest_message(hash, message)};
-  auto value{bignum_from_bytes(digest)};
+  auto value{bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(digest)};
   const auto digest_bits{digest.size() * 8};
   if (digest_bits > order_bits) {
     value = bignum_shift_right(value, digest_bits - order_bits);
@@ -284,8 +284,10 @@ auto verify_ecdsa(const EllipticCurve curve, const SignatureHashFunction hash,
     return false;
   }
 
-  const auto r{bignum_from_bytes(signature.substr(0, field_bytes))};
-  const auto s{bignum_from_bytes(signature.substr(field_bytes))};
+  const auto r{bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(
+      signature.substr(0, field_bytes))};
+  const auto s{
+      bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(signature.substr(field_bytes))};
 
   // FIPS 186-4 Section 6.4.2 step 1: both integers must lie in [1, n - 1]
   if (bignum_is_zero(r) || bignum_compare(r, parameters.order) >= 0 ||
@@ -301,8 +303,8 @@ auto verify_ecdsa(const EllipticCurve curve, const SignatureHashFunction hash,
     return false;
   }
 
-  const auto public_x{bignum_from_bytes(stripped_x)};
-  const auto public_y{bignum_from_bytes(stripped_y)};
+  const auto public_x{bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(stripped_x)};
+  const auto public_y{bignum_from_bytes<CURVE_BIGNUM_CAPACITY>(stripped_y)};
 
   // The public key must be a valid point: coordinates below the field prime and
   // satisfying the curve equation
@@ -321,9 +323,11 @@ auto verify_ecdsa(const EllipticCurve curve, const SignatureHashFunction hash,
 
   const JacobianPoint generator{.x = parameters.generator_x,
                                 .y = parameters.generator_y,
-                                .z = bignum_from_u64(1)};
+                                .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
   const JacobianPoint public_point{
-      .x = public_x, .y = public_y, .z = bignum_from_u64(1)};
+      .x = public_x,
+      .y = public_y,
+      .z = bignum_from_u64<CURVE_BIGNUM_CAPACITY>(1)};
   const auto point{point_double_scalar_multiply(u1, generator, u2, public_point,
                                                 parameters)};
 
diff --git a/vendor/core/src/core/crypto/crypto_verify_windows.cc b/vendor/core/src/core/crypto/crypto_verify_windows.cc
index 399d4219..7fe08043 100644
--- a/vendor/core/src/core/crypto/crypto_verify_windows.cc
+++ b/vendor/core/src/core/crypto/crypto_verify_windows.cc
@@ -3,6 +3,7 @@
 
 #include "crypto_eddsa.h"
 #include "crypto_helpers.h"
+#include "crypto_system.h"
 
 #define WIN32_LEAN_AND_MEAN
 #ifndef NOMINMAX
diff --git a/vendor/core/src/core/gzip/CMakeLists.txt b/vendor/core/src/core/gzip/CMakeLists.txt
index 4365ee11..f9516f8d 100644
--- a/vendor/core/src/core/gzip/CMakeLists.txt
+++ b/vendor/core/src/core/gzip/CMakeLists.txt
@@ -4,9 +4,6 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME gzip
 
 target_link_libraries(sourcemeta_core_gzip PRIVATE sourcemeta::core::crypto)
 
-# Way faster for full buffer decompression
-target_link_libraries(sourcemeta_core_gzip PRIVATE LibDeflate::LibDeflate)
-
 if(SOURCEMETA_CORE_INSTALL)
   sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME gzip)
 endif()
diff --git a/vendor/core/src/core/gzip/bit_reader.h b/vendor/core/src/core/gzip/bit_reader.h
deleted file mode 100644
index bbffdae0..00000000
--- a/vendor/core/src/core/gzip/bit_reader.h
+++ /dev/null
@@ -1,155 +0,0 @@
-#ifndef SOURCEMETA_CORE_GZIP_BIT_READER_H_
-#define SOURCEMETA_CORE_GZIP_BIT_READER_H_
-
-#include <sourcemeta/core/gzip_error.h>
-
-#include <array>   // std::array
-#include <cassert> // assert
-#include <cstddef> // std::size_t
-#include <cstdint> // std::uint8_t, std::uint32_t, std::uint64_t
-#include <istream> // std::istream
-
-namespace sourcemeta::core {
-
-class BitReader {
-public:
-  BitReader(std::istream &source) : source_{&source} {}
-
-  auto read_bits(const unsigned int count) -> std::uint32_t {
-    const auto value{this->peek_bits(count)};
-    this->consume_bits(count);
-    return value;
-  }
-
-  auto peek_bits(const unsigned int count) -> std::uint32_t {
-    // Callers in this module always pass count in [0, 32]; larger shifts
-    // would be undefined behaviour against the 64-bit accumulator. The
-    // assert documents the contract without paying a release-build cost
-    assert(count <= 32);
-    if (this->bits_available_ < count) {
-      this->refill_for(count);
-    }
-    const auto mask{(static_cast<std::uint64_t>(1) << count) - 1};
-    return static_cast<std::uint32_t>(this->accumulator_ & mask);
-  }
-
-  auto consume_bits(const unsigned int count) -> void {
-    // Consuming more bits than are buffered would underflow the unsigned
-    // counter. Every call site is preceded by a peek or refill that
-    // guarantees enough bits, so the assert documents the contract
-    assert(count <= this->bits_available_);
-    this->accumulator_ >>= count;
-    this->bits_available_ -= count;
-  }
-
-  auto align_to_byte() -> void {
-    const auto trailing_bits{this->bits_available_ % 8};
-    this->accumulator_ >>= trailing_bits;
-    this->bits_available_ -= trailing_bits;
-  }
-
-  auto read_byte() -> std::uint8_t {
-    // Reading a byte while 1 to 7 bits are buffered would return a byte from
-    // ahead of them. Every call site is byte-aligned, so the assert documents
-    // the invariant without paying a release-build cost
-    assert(this->bits_available_ % 8 == 0);
-    if (this->bits_available_ >= 8) {
-      const auto value{static_cast<std::uint8_t>(this->accumulator_ & 0xff)};
-      this->accumulator_ >>= 8;
-      this->bits_available_ -= 8;
-      return value;
-    }
-    return this->pull_source_byte();
-  }
-
-  auto try_read_byte(std::uint8_t &byte) -> bool {
-    assert(this->bits_available_ % 8 == 0);
-    if (this->bits_available_ >= 8) {
-      byte = static_cast<std::uint8_t>(this->accumulator_ & 0xff);
-      this->accumulator_ >>= 8;
-      this->bits_available_ -= 8;
-      return true;
-    }
-    if (this->buffer_position_ >= this->buffer_size_ &&
-        !this->try_refill_buffer()) {
-      return false;
-    }
-    byte = this->buffer_[this->buffer_position_++];
-    return true;
-  }
-
-  auto read_bytes(std::uint8_t *destination, const std::size_t count) -> void {
-    for (std::size_t index = 0; index < count; ++index) {
-      destination[index] = this->read_byte();
-    }
-  }
-
-private:
-  static constexpr std::size_t SOURCE_BUFFER_SIZE{4096};
-
-  auto pull_source_byte() -> std::uint8_t {
-    if (this->buffer_position_ >= this->buffer_size_) {
-      this->refill_buffer();
-    }
-    return this->buffer_[this->buffer_position_++];
-  }
-
-  auto refill_for(const unsigned int count) -> void {
-    // Fast path: if 4 bytes available in the input buffer and the
-    // accumulator has room for 32 more bits, load 4 bytes at once.
-    // RFC 1951 packs bits LSB-first within each byte, so the first byte
-    // contributes the low 8 bits of the loaded word regardless of host
-    // endianness. Construct the 32-bit value explicitly to keep this
-    // portable on big-endian hosts
-    if (this->bits_available_ <= 32 &&
-        this->buffer_position_ + 4 <= this->buffer_size_) {
-      const std::uint32_t four_bytes{
-          static_cast<std::uint32_t>(this->buffer_[this->buffer_position_]) |
-          (static_cast<std::uint32_t>(this->buffer_[this->buffer_position_ + 1])
-           << 8) |
-          (static_cast<std::uint32_t>(this->buffer_[this->buffer_position_ + 2])
-           << 16) |
-          (static_cast<std::uint32_t>(this->buffer_[this->buffer_position_ + 3])
-           << 24)};
-      this->accumulator_ |= static_cast<std::uint64_t>(four_bytes)
-                            << this->bits_available_;
-      this->bits_available_ += 32;
-      this->buffer_position_ += 4;
-    }
-    while (this->bits_available_ < count) {
-      const auto byte{this->pull_source_byte()};
-      this->accumulator_ |= static_cast<std::uint64_t>(byte)
-                            << this->bits_available_;
-      this->bits_available_ += 8;
-    }
-  }
-
-  auto refill_buffer() -> void {
-    if (!this->try_refill_buffer()) {
-      throw GZIPError{"Unexpected end of source stream"};
-    }
-  }
-
-  auto try_refill_buffer() -> bool {
-    this->source_->read(reinterpret_cast<char *>(this->buffer_.data()),
-                        SOURCE_BUFFER_SIZE);
-    const auto bytes_read{static_cast<std::size_t>(this->source_->gcount())};
-    if (bytes_read == 0) {
-      return false;
-    }
-    this->buffer_size_ = bytes_read;
-    this->buffer_position_ = 0;
-    return true;
-  }
-
-  std::istream *source_;
-  std::uint64_t accumulator_{0};
-  unsigned int bits_available_{0};
-  std::array<std::uint8_t, SOURCE_BUFFER_SIZE> buffer_{};
-  std::size_t buffer_position_{0};
-  std::size_t buffer_size_{0};
-};
-
-} // namespace sourcemeta::core
-
-#endif
diff --git a/vendor/core/src/core/gzip/deflate.h b/vendor/core/src/core/gzip/deflate.h
index d45ddada..509fcb28 100644
--- a/vendor/core/src/core/gzip/deflate.h
+++ b/vendor/core/src/core/gzip/deflate.h
@@ -1,409 +1,1124 @@
 #ifndef SOURCEMETA_CORE_GZIP_DEFLATE_H_
 #define SOURCEMETA_CORE_GZIP_DEFLATE_H_
 
-#include "bit_reader.h"
-#include "huffman.h"
+#include "inflate.h"
 
-#include <sourcemeta/core/gzip_error.h>
-
-#include <algorithm> // std::min
+#include <algorithm> // std::sort, std::fill, std::min
 #include <array>     // std::array
-#include <cassert>   // assert
+#include <bit>       // std::endian, std::byteswap, std::countr_zero
 #include <cstddef>   // std::size_t
-#include <cstdint>   // std::uint8_t, std::uint16_t
-#include <cstring>   // std::memcpy
+#include <cstdint> // std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t
+#include <cstring> // std::memcpy
+#include <vector>  // std::vector
 
 namespace sourcemeta::core {
 
+inline constexpr std::size_t DEFLATE_MAXIMUM_MATCH_LENGTH{258};
 inline constexpr std::size_t DEFLATE_WINDOW_SIZE{32768};
-inline constexpr std::size_t DEFLATE_WINDOW_MASK{DEFLATE_WINDOW_SIZE - 1};
-static_assert((DEFLATE_WINDOW_SIZE & DEFLATE_WINDOW_MASK) == 0,
-              "DEFLATE_WINDOW_SIZE must be a power of two");
-
-// RFC 1951 section 3.2.5 length codes 257-285
-inline constexpr std::array<std::uint16_t, 29> DEFLATE_LENGTH_BASE{
-    {3,  4,  5,  6,  7,  8,  9,  10, 11,  13,  15,  17,  19,  23, 27,
-     31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258}};
-
-inline constexpr std::array<std::uint8_t, 29> DEFLATE_LENGTH_EXTRA{
-    {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2,
-     2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0}};
-
-// RFC 1951 section 3.2.5 distance codes 0-29
-inline constexpr std::array<std::uint16_t, 30> DEFLATE_DISTANCE_BASE{
-    {1,    2,    3,    4,    5,    7,    9,    13,    17,    25,
-     33,   49,   65,   97,   129,  193,  257,  385,   513,   769,
-     1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577}};
-
-inline constexpr std::array<std::uint8_t, 30> DEFLATE_DISTANCE_EXTRA{
-    {0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
-     6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}};
-
-// RFC 1951 section 3.2.7 code-length-of-codes order
-inline constexpr std::array<std::uint8_t, 19> DEFLATE_CODE_LENGTH_ORDER{
-    {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}};
-
-class DeflateDecoder {
+inline constexpr std::size_t DEFLATE_MAXIMUM_STORED_LENGTH{65535};
+inline constexpr std::uint32_t DEFLATE_END_OF_BLOCK{256};
+
+// The index of the length symbol, counting from symbol 257, for every match
+// length as per RFC 1951 section 3.2.5
+inline constexpr std::array<std::uint8_t, 259> DEFLATE_LENGTH_SLOTS{
+    {0,  0,  0,  0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9,  10, 10, 11, 11,
+     12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16,
+     16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18,
+     18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+     20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+     21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+     22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24,
+     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25,
+     25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+     25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+     26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27,
+     27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+     27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28}};
+
+// The distance symbol for every distance up to 256 in the first half, and for
+// every larger distance indexed by its value minus one divided by 128 in the
+// second half, as every symbol past 256 spans whole multiples of 128
+inline constexpr std::array<std::uint8_t, 512> DEFLATE_DISTANCE_SLOTS{
+    {0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,
+     8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,  10, 10, 10, 10, 10, 10,
+     10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+     11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+     12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+     12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+     13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14,
+     14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+     14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+     14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+     14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+     15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+     15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+     15, 15, 15, 15, 15, 15, 15, 15, 15, 0,  0,  16, 17, 18, 18, 19, 19, 20, 20,
+     20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23,
+     23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+     25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26,
+     26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+     26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+     27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+     27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+     28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+     28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+     28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29}};
+
+inline auto deflate_distance_slot(const std::size_t distance) -> std::size_t {
+  return distance <= 256 ? DEFLATE_DISTANCE_SLOTS[distance - 1]
+                         : DEFLATE_DISTANCE_SLOTS[256 + ((distance - 1) >> 7)];
+}
+
+// Packs bits starting from the least significant bit of each byte as per
+// RFC 1951 section 3.1.1. The destination must always have room for a whole
+// word past the bytes written so far
+class DeflateBitWriter {
 public:
-  DeflateDecoder(BitReader &reader) : reader_{&reader} {}
+  DeflateBitWriter(std::uint8_t *output) : next_{output} {}
 
-  auto decompress(std::uint8_t *output, const std::size_t output_size)
-      -> std::size_t {
-    std::size_t produced{0};
-
-    while (!this->stream_ended_) {
-      switch (this->state_) {
-        case State::BlockHeader:
-          if (this->final_block_) {
-            this->state_ = State::End;
-          } else {
-            this->start_block();
-          }
-          break;
-        case State::StoredBlock:
-          this->process_stored_block(output, output_size, produced);
-          if (this->state_ == State::StoredBlock) {
-            return produced;
-          }
-          break;
-        case State::HuffmanBlock:
-          this->process_huffman_block(output, output_size, produced);
-          if (this->state_ == State::HuffmanBlock) {
-            return produced;
-          }
-          break;
-        case State::End:
-          this->reader_->align_to_byte();
-          this->stream_ended_ = true;
-          return produced;
-      }
-    }
-    return produced;
+  // The buffer holds 64 bits, and a flush leaves at most seven of them, so
+  // callers flush before the bits added since the last flush exceed 57
+  auto add(const std::uint32_t value, const unsigned int count) -> void {
+    this->buffer_ |= static_cast<std::uint64_t>(value) << this->count_;
+    this->count_ += count;
   }
 
-  [[nodiscard]] auto stream_ended() const -> bool {
-    return this->stream_ended_;
+  auto flush() -> void {
+    std::uint64_t word{this->buffer_};
+    if (std::endian::native == std::endian::big) {
+      word = std::byteswap(word);
+    }
+
+    std::memcpy(this->next_, &word, sizeof(word));
+    const auto bytes{this->count_ >> 3};
+    this->next_ += bytes;
+    this->buffer_ >>= bytes * 8;
+    this->count_ -= bytes * 8;
   }
 
-  auto reset() -> void {
-    this->state_ = State::BlockHeader;
-    this->final_block_ = false;
-    this->stream_ended_ = false;
-    this->stored_remaining_ = 0;
-    this->pending_copy_length_ = 0;
-    this->pending_copy_distance_ = 0;
-    this->window_position_ = 0;
-    this->bytes_written_ = 0;
+  auto align() -> void {
+    this->flush();
+    if (this->count_ > 0) {
+      this->next_ += 1;
+    }
+
+    this->buffer_ = 0;
+    this->count_ = 0;
   }
 
-private:
-  enum class State : std::uint8_t {
-    BlockHeader,
-    StoredBlock,
-    HuffmanBlock,
-    End,
-  };
-
-  auto start_block() -> void {
-    this->final_block_ = this->reader_->read_bits(1) != 0;
-    const auto btype{this->reader_->read_bits(2)};
-    switch (btype) {
-      case 0:
-        this->start_stored_block();
-        break;
-      case 1:
-        this->build_fixed_trees();
-        this->state_ = State::HuffmanBlock;
-        break;
-      case 2:
-        this->read_dynamic_header();
-        this->state_ = State::HuffmanBlock;
-        break;
-      default:
-        throw GZIPError{"Reserved deflate block type"};
+  auto bytes(const std::uint8_t *data, const std::size_t size) -> void {
+    if (size > 0) {
+      std::memcpy(this->next_, data, size);
     }
+
+    this->next_ += size;
   }
 
-  auto start_stored_block() -> void {
-    this->reader_->align_to_byte();
-    this->stored_remaining_ =
-        static_cast<std::uint16_t>(this->reader_->read_byte()) |
-        static_cast<std::uint16_t>(
-            static_cast<std::uint16_t>(this->reader_->read_byte()) << 8);
-    const auto nlen_lo{this->reader_->read_byte()};
-    const auto nlen_hi{this->reader_->read_byte()};
-    const std::uint16_t nlen{static_cast<std::uint16_t>(
-        static_cast<std::uint16_t>(nlen_lo) |
-        static_cast<std::uint16_t>(static_cast<std::uint16_t>(nlen_hi) << 8))};
-    const std::uint16_t expected_nlen{
-        static_cast<std::uint16_t>(~this->stored_remaining_)};
-    if (expected_nlen != nlen) {
-      throw GZIPError{"Stored block LEN/NLEN mismatch"};
-    }
-    this->state_ = State::StoredBlock;
+  [[nodiscard]] auto pending_bits() const -> unsigned int {
+    return this->count_;
   }
 
-  auto build_fixed_trees() -> void {
-    std::array<std::uint8_t, 288> literal_lengths{};
-    for (std::size_t index = 0; index < 144; ++index) {
-      literal_lengths[index] = 8;
+  [[nodiscard]] auto position() const -> std::uint8_t * { return this->next_; }
+
+private:
+  std::uint8_t *next_;
+  std::uint64_t buffer_{0};
+  unsigned int count_{0};
+};
+
+// Scratch space for computing length-limited codes with the package-merge
+// algorithm, where every list holds at most twice as many items as symbols
+class DeflateCodeBuilder {
+public:
+  // Assigns every symbol with a nonzero frequency a codeword length of at most
+  // the given limit, minimizing the total encoded size. The resulting code is
+  // always complete, adding placeholder symbols when fewer than two are used
+  auto lengths(const std::uint32_t *frequencies, const std::size_t symbol_count,
+               const unsigned int limit, std::uint8_t *lengths) -> void {
+    std::fill(lengths, lengths + symbol_count, std::uint8_t{0});
+    std::size_t used{0};
+    for (std::size_t symbol = 0; symbol < symbol_count; ++symbol) {
+      if (frequencies[symbol] != 0) {
+        this->symbols_[used] = static_cast<std::uint16_t>(symbol);
+        used += 1;
+      }
+    }
+
+    if (used < 2) {
+      const std::size_t first{used == 1
+                                  ? static_cast<std::size_t>(this->symbols_[0])
+                                  : std::size_t{0}};
+      lengths[first] = 1;
+      lengths[first == 0 ? 1 : 0] = 1;
+      return;
     }
-    for (std::size_t index = 144; index < 256; ++index) {
-      literal_lengths[index] = 9;
+
+    std::sort(
+        this->symbols_.begin(), this->symbols_.begin() + used,
+        [frequencies](const std::uint16_t left, const std::uint16_t right) {
+          return frequencies[left] != frequencies[right]
+                     ? frequencies[left] < frequencies[right]
+                     : left < right;
+        });
+
+    // A plain Huffman code is optimal whenever no codeword exceeds the limit,
+    // and building it takes linear time over the sorted frequencies
+    if (this->unlimited_lengths(frequencies, used, limit, lengths)) {
+      return;
     }
-    for (std::size_t index = 256; index < 280; ++index) {
-      literal_lengths[index] = 7;
+
+    std::fill(lengths, lengths + symbol_count, std::uint8_t{0});
+
+    // The deepest list holds only the symbols. Every shallower list merges the
+    // symbols with the pairs of consecutive items of the list below it
+    const std::size_t deepest{limit - 1};
+    for (std::size_t index = 0; index < used; ++index) {
+      this->weights_[deepest][index] = frequencies[this->symbols_[index]];
+      this->leaves_[deepest][index] = 1;
     }
-    for (std::size_t index = 280; index < 288; ++index) {
-      literal_lengths[index] = 8;
+
+    this->sizes_[deepest] = used;
+    for (std::size_t level = deepest; level > 0; --level) {
+      const std::size_t below{level};
+      const std::size_t current{level - 1};
+      const std::size_t packages{this->sizes_[below] / 2};
+      std::size_t leaf{0};
+      std::size_t package{0};
+      std::size_t size{0};
+      while (leaf < used || package < packages) {
+        const std::uint64_t package_weight{
+            package < packages ? this->weights_[below][package * 2] +
+                                     this->weights_[below][(package * 2) + 1]
+                               : 0};
+        if (package >= packages ||
+            (leaf < used &&
+             frequencies[this->symbols_[leaf]] <= package_weight)) {
+          this->weights_[current][size] = frequencies[this->symbols_[leaf]];
+          this->leaves_[current][size] = 1;
+          leaf += 1;
+        } else {
+          this->weights_[current][size] = package_weight;
+          this->leaves_[current][size] = 0;
+          package += 1;
+        }
+
+        size += 1;
+      }
+
+      this->sizes_[current] = size;
     }
-    this->literal_length_tree_.build(literal_lengths.data(),
-                                     literal_lengths.size());
 
-    std::array<std::uint8_t, 30> distance_lengths{};
-    for (auto &length : distance_lengths) {
-      length = 5;
+    // Selecting the cheapest items of the shallowest list determines how many
+    // items of every deeper list take part, and a symbol gains one bit of
+    // length for every list where it is selected
+    std::size_t selected{(used * 2) - 2};
+    for (std::size_t level = 0; level < limit; ++level) {
+      std::size_t leaves{0};
+      for (std::size_t index = 0; index < selected; ++index) {
+        leaves += this->leaves_[level][index];
+      }
+
+      for (std::size_t index = 0; index < leaves; ++index) {
+        lengths[this->symbols_[index]] += 1;
+      }
+
+      selected = (selected - leaves) * 2;
     }
-    this->distance_tree_.build(distance_lengths.data(), distance_lengths.size(),
-                               true);
   }
 
-  auto read_dynamic_header() -> void {
-    const auto hlit{this->reader_->read_bits(5) + 257};
-    const auto hdist{this->reader_->read_bits(5) + 1};
-    const auto hclen{this->reader_->read_bits(4) + 4};
+  // Builds a Huffman code by repeatedly joining the two lightest nodes, taking
+  // them from either the sorted symbols or the internal nodes created so far,
+  // which are created in order of weight. Returns whether every codeword fits
+  // within the limit
+  auto unlimited_lengths(const std::uint32_t *frequencies,
+                         const std::size_t used, const unsigned int limit,
+                         std::uint8_t *lengths) -> bool {
+    std::size_t leaf{0};
+    std::size_t internal{0};
+    for (std::size_t node = 0; node + 1 < used; ++node) {
+      std::uint64_t weight{0};
+      for (std::size_t child = 0; child < 2; ++child) {
+        if (leaf < used &&
+            (internal >= node || frequencies[this->symbols_[leaf]] <=
+                                     this->internal_weights_[internal])) {
+          this->leaf_parents_[leaf] = static_cast<std::uint16_t>(node);
+          weight += frequencies[this->symbols_[leaf]];
+          leaf += 1;
+        } else {
+          this->internal_parents_[internal] = static_cast<std::uint16_t>(node);
+          weight += this->internal_weights_[internal];
+          internal += 1;
+        }
+      }
 
-    // RFC 1951 section 3.2.7 caps the literal/length alphabet at 286 symbols
-    if (hlit > 286) {
-      throw GZIPError{"Too many literal/length codes"};
+      this->internal_weights_[node] = weight;
     }
 
-    std::array<std::uint8_t, 19> code_length_lengths{};
-    for (std::size_t index = 0; index < hclen; ++index) {
-      code_length_lengths[DEFLATE_CODE_LENGTH_ORDER[index]] =
-          static_cast<std::uint8_t>(this->reader_->read_bits(3));
+    // Every internal node has a later parent, so walking backwards from the
+    // root assigns every depth after the depth of its parent
+    const std::size_t root{used - 2};
+    this->internal_depths_[root] = 0;
+    for (std::size_t node = root; node > 0; --node) {
+      this->internal_depths_[node - 1] = static_cast<std::uint16_t>(
+          this->internal_depths_[this->internal_parents_[node - 1]] + 1);
+    }
+
+    for (std::size_t index = 0; index < used; ++index) {
+      const unsigned int depth{
+          static_cast<unsigned int>(
+              this->internal_depths_[this->leaf_parents_[index]]) +
+          1U};
+      if (depth > limit) {
+        return false;
+      }
+
+      lengths[this->symbols_[index]] = static_cast<std::uint8_t>(depth);
+    }
+
+    return true;
+  }
+
+private:
+  static constexpr std::size_t MAXIMUM_ITEMS{INFLATE_LITERAL_LENGTH_SYMBOLS *
+                                             2};
+
+  std::array<std::uint16_t, INFLATE_LITERAL_LENGTH_SYMBOLS> symbols_{};
+  std::array<std::array<std::uint64_t, MAXIMUM_ITEMS>,
+             INFLATE_MAXIMUM_CODEWORD_LENGTH>
+      weights_{};
+  std::array<std::array<std::uint8_t, MAXIMUM_ITEMS>,
+             INFLATE_MAXIMUM_CODEWORD_LENGTH>
+      leaves_{};
+  std::array<std::size_t, INFLATE_MAXIMUM_CODEWORD_LENGTH> sizes_{};
+  std::array<std::uint64_t, INFLATE_LITERAL_LENGTH_SYMBOLS> internal_weights_{};
+  std::array<std::uint16_t, INFLATE_LITERAL_LENGTH_SYMBOLS> internal_parents_{};
+  std::array<std::uint16_t, INFLATE_LITERAL_LENGTH_SYMBOLS> internal_depths_{};
+  std::array<std::uint16_t, INFLATE_LITERAL_LENGTH_SYMBOLS> leaf_parents_{};
+};
+
+// Assigns canonical codewords as per RFC 1951 section 3.2.2, bit-reversed so
+// they can be written starting from the least significant bit
+inline auto deflate_canonical_codes(const std::uint8_t *lengths,
+                                    const std::size_t symbol_count,
+                                    std::uint16_t *codes) -> void {
+  std::array<std::uint16_t, INFLATE_MAXIMUM_CODEWORD_LENGTH + 1> counts{};
+  for (std::size_t symbol = 0; symbol < symbol_count; ++symbol) {
+    counts[lengths[symbol]] += 1;
+  }
+
+  counts[0] = 0;
+  std::array<std::uint32_t, INFLATE_MAXIMUM_CODEWORD_LENGTH + 1> next{};
+  std::uint32_t code{0};
+  for (unsigned int length = 1; length <= INFLATE_MAXIMUM_CODEWORD_LENGTH;
+       ++length) {
+    code = (code + counts[length - 1]) << 1;
+    next[length] = code;
+  }
+
+  for (std::size_t symbol = 0; symbol < symbol_count; ++symbol) {
+    const auto length{lengths[symbol]};
+    if (length != 0) {
+      codes[symbol] = static_cast<std::uint16_t>(
+          inflate_reverse_bits(next[length], length));
+      next[length] += 1;
+    } else {
+      codes[symbol] = 0;
     }
+  }
+}
+
+// The fixed codes of RFC 1951 section 3.2.6
+struct DeflateFixedCodes {
+  std::array<std::uint8_t, INFLATE_LITERAL_LENGTH_SYMBOLS>
+      literal_length_lengths{};
+  std::array<std::uint16_t, INFLATE_LITERAL_LENGTH_SYMBOLS>
+      literal_length_codes{};
+  std::array<std::uint8_t, INFLATE_DISTANCE_SYMBOLS> distance_lengths{};
+  std::array<std::uint16_t, INFLATE_DISTANCE_SYMBOLS> distance_codes{};
+
+  DeflateFixedCodes() {
+    std::fill(this->literal_length_lengths.begin(),
+              this->literal_length_lengths.begin() + 144, std::uint8_t{8});
+    std::fill(this->literal_length_lengths.begin() + 144,
+              this->literal_length_lengths.begin() + 256, std::uint8_t{9});
+    std::fill(this->literal_length_lengths.begin() + 256,
+              this->literal_length_lengths.begin() + 280, std::uint8_t{7});
+    std::fill(this->literal_length_lengths.begin() + 280,
+              this->literal_length_lengths.end(), std::uint8_t{8});
+    deflate_canonical_codes(this->literal_length_lengths.data(),
+                            this->literal_length_lengths.size(),
+                            this->literal_length_codes.data());
+    std::fill(this->distance_lengths.begin(), this->distance_lengths.end(),
+              std::uint8_t{5});
+    deflate_canonical_codes(this->distance_lengths.data(),
+                            this->distance_lengths.size(),
+                            this->distance_codes.data());
+  }
+};
 
-    HuffmanDecoder code_length_tree;
-    code_length_tree.build(code_length_lengths.data(),
-                           code_length_lengths.size());
+// A code length sequence compressed with the repeat symbols of RFC 1951
+// section 3.2.7
+struct DeflateCodeLengthRun {
+  std::array<std::uint8_t,
+             INFLATE_LITERAL_LENGTH_SYMBOLS + INFLATE_DISTANCE_SYMBOLS>
+      symbols{};
+  std::array<std::uint8_t,
+             INFLATE_LITERAL_LENGTH_SYMBOLS + INFLATE_DISTANCE_SYMBOLS>
+      extra{};
+  std::size_t size{0};
 
-    std::array<std::uint8_t, 288 + 32> all_lengths{};
+  auto push(const std::uint8_t symbol, const std::uint8_t value) -> void {
+    this->symbols[this->size] = symbol;
+    this->extra[this->size] = value;
+    this->size += 1;
+  }
+
+  auto encode(const std::uint8_t *lengths, const std::size_t count) -> void {
+    this->size = 0;
     std::size_t index{0};
-    while (index < hlit + hdist) {
-      const auto symbol{code_length_tree.decode(*this->reader_)};
-      if (symbol < 16) {
-        all_lengths[index++] = static_cast<std::uint8_t>(symbol);
-      } else if (symbol == 16) {
-        if (index == 0) {
-          throw GZIPError{"Repeat-previous code length with no previous"};
-        }
-        const auto previous{all_lengths[index - 1]};
-        const auto repeats{this->reader_->read_bits(2) + 3};
-        for (std::size_t step = 0; step < repeats; ++step) {
-          if (index >= all_lengths.size()) {
-            throw GZIPError{"Code length count overflow"};
-          }
-          all_lengths[index++] = previous;
+    while (index < count) {
+      const auto value{lengths[index]};
+      std::size_t run{1};
+      while (index + run < count && lengths[index + run] == value) {
+        run += 1;
+      }
+
+      if (value == 0) {
+        while (run >= 11) {
+          const auto amount{std::min(run, std::size_t{138})};
+          this->push(18, static_cast<std::uint8_t>(amount - 11));
+          run -= amount;
+          index += amount;
         }
-      } else if (symbol == 17) {
-        const auto repeats{this->reader_->read_bits(3) + 3};
-        for (std::size_t step = 0; step < repeats; ++step) {
-          if (index >= all_lengths.size()) {
-            throw GZIPError{"Code length count overflow"};
-          }
-          all_lengths[index++] = 0;
+
+        if (run >= 3) {
+          this->push(17, static_cast<std::uint8_t>(run - 3));
+          index += run;
+          run = 0;
         }
       } else {
-        // The code length tree is built over a 19 symbol alphabet, so its
-        // decoder can never hand back anything past symbol 18
-        assert(symbol == 18);
-        const auto repeats{this->reader_->read_bits(7) + 11};
-        for (std::size_t step = 0; step < repeats; ++step) {
-          if (index >= all_lengths.size()) {
-            throw GZIPError{"Code length count overflow"};
-          }
-          all_lengths[index++] = 0;
+        this->push(value, 0);
+        index += 1;
+        run -= 1;
+        while (run >= 3) {
+          const auto amount{std::min(run, std::size_t{6})};
+          this->push(16, static_cast<std::uint8_t>(amount - 3));
+          run -= amount;
+          index += amount;
         }
       }
+
+      while (run > 0) {
+        this->push(value, 0);
+        index += 1;
+        run -= 1;
+      }
+    }
+  }
+};
+
+inline constexpr std::array<std::uint8_t, INFLATE_CODE_LENGTH_SYMBOLS>
+    DEFLATE_CODE_LENGTH_EXTRA_BITS{
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7}};
+
+// A run of literal bytes followed by a match, where a zero length marks a
+// trailing run with no match
+struct DeflateSequence {
+  std::uint32_t literals;
+  std::uint16_t length;
+  std::uint16_t distance;
+};
+
+struct DeflateLevel {
+  unsigned int search_depth;
+  unsigned int nice_length;
+  bool lazy;
+};
+
+// Levels 0 and 1 use dedicated strategies, so their entries are unused
+inline constexpr std::array<DeflateLevel, 13> DEFLATE_LEVELS{
+    {{.search_depth = 0, .nice_length = 0, .lazy = false},
+     {.search_depth = 0, .nice_length = 0, .lazy = false},
+     {.search_depth = 4, .nice_length = 16, .lazy = false},
+     {.search_depth = 8, .nice_length = 32, .lazy = false},
+     {.search_depth = 16, .nice_length = 64, .lazy = false},
+     {.search_depth = 16, .nice_length = 32, .lazy = true},
+     {.search_depth = 32, .nice_length = 128, .lazy = true},
+     {.search_depth = 64, .nice_length = 128, .lazy = true},
+     {.search_depth = 128, .nice_length = 258, .lazy = true},
+     {.search_depth = 256, .nice_length = 258, .lazy = true},
+     {.search_depth = 512, .nice_length = 258, .lazy = true},
+     {.search_depth = 1024, .nice_length = 258, .lazy = true},
+     {.search_depth = 4096, .nice_length = 258, .lazy = true}}};
+
+// Compresses a whole buffer into a raw deflate stream (RFC 1951)
+class DeflateEncoder {
+public:
+  // Symbols are accumulated for this much input before a block is emitted
+  // with codes tailored to it. The fastest level uses shorter blocks with a cap
+  // on their sequences, so its codes follow changes in the input more closely,
+  // and a shorter remainder is merged into the last block instead of forming a
+  // tiny one
+  static constexpr std::size_t BLOCK_INPUT_LENGTH{262144};
+  static constexpr std::size_t FAST_BLOCK_INPUT_LENGTH{65535};
+  static constexpr std::size_t FAST_BLOCK_SEQUENCES{8192};
+  static constexpr std::size_t MINIMUM_BLOCK_LENGTH{5000};
+
+  // Every match covers at least four bytes and a block overshoots its input
+  // length by at most one match, which bounds the sequences per block
+  DeflateEncoder(const int level, const std::size_t size)
+      : level_{level},
+        sequences_(((std::min(size, BLOCK_INPUT_LENGTH + MINIMUM_BLOCK_LENGTH) +
+                     DEFLATE_MAXIMUM_MATCH_LENGTH) /
+                    4) +
+                   2),
+        head_(level == 0 ? 0 : HASH_SIZE),
+        previous_(level <= 1 ? 0 : DEFLATE_WINDOW_SIZE) {}
+
+  // The largest possible stream for an input of the given size, including a
+  // whole word of room for flushing bits
+  static auto bound(const std::size_t size) -> std::size_t {
+    const std::size_t stored_chunks{(size + DEFLATE_MAXIMUM_STORED_LENGTH - 1) /
+                                    DEFLATE_MAXIMUM_STORED_LENGTH};
+    // A block that is not the last covers at least as many bytes as the
+    // sequences it can hold, each of which spans at least four bytes
+    const std::size_t blocks{(size / (FAST_BLOCK_SEQUENCES * 4)) + 1};
+    return size + (5 * (stored_chunks + blocks)) + 16;
+  }
+
+  auto compress(const std::uint8_t *input, const std::size_t size,
+                std::uint8_t *output) -> std::size_t {
+    DeflateBitWriter writer{output};
+    if (this->level_ == 0) {
+      this->emit_stored(writer, input, size, true);
+      writer.align();
+      return static_cast<std::size_t>(writer.position() - output);
     }
 
-    if (index != hlit + hdist) {
-      throw GZIPError{"Code length count overflow"};
+    std::size_t position{0};
+    while (true) {
+      const std::size_t block_start{position};
+      const std::size_t block_length{this->level_ == 1 ? FAST_BLOCK_INPUT_LENGTH
+                                                       : BLOCK_INPUT_LENGTH};
+      const std::size_t block_end{size - position <
+                                          block_length + MINIMUM_BLOCK_LENGTH
+                                      ? size
+                                      : position + block_length};
+      this->literal_length_frequencies_.fill(0);
+      this->distance_frequencies_.fill(0);
+      this->sequence_count_ = 0;
+      if (this->level_ == 1) {
+        position = this->match_fast(input, size, position, block_end);
+      } else {
+        position = this->match_chains(input, size, position, block_end);
+      }
+
+      const bool final{position >= size};
+      this->emit_block(writer, input + block_start, position - block_start,
+                       final);
+      if (final) {
+        break;
+      }
     }
 
-    this->literal_length_tree_.build(all_lengths.data(), hlit);
-    this->distance_tree_.build(all_lengths.data() + hlit, hdist);
+    writer.align();
+    return static_cast<std::size_t>(writer.position() - output);
   }
 
-  auto process_stored_block(std::uint8_t *output, const std::size_t output_size,
-                            std::size_t &produced) -> void {
-    while (this->stored_remaining_ > 0 && produced < output_size) {
-      const auto byte{this->reader_->read_byte()};
-      this->emit(byte, output, output_size, produced);
-      --this->stored_remaining_;
+private:
+  static constexpr unsigned int HASH_BITS{16};
+  static constexpr std::size_t HASH_SIZE{std::size_t{1} << HASH_BITS};
+  static constexpr std::size_t WINDOW_MASK{DEFLATE_WINDOW_SIZE - 1};
+
+  // The fastest level spreads the same table over twice as few buckets, each
+  // holding the two most recent positions
+  static constexpr unsigned int FAST_HASH_BITS{HASH_BITS - 1};
+  static constexpr std::size_t FAST_NICE_LENGTH{32};
+
+  static auto load_32(const std::uint8_t *data) -> std::uint32_t {
+    std::uint32_t word{0};
+    std::memcpy(&word, data, sizeof(word));
+    if (std::endian::native == std::endian::big) {
+      word = std::byteswap(word);
     }
-    if (this->stored_remaining_ == 0) {
-      this->state_ = State::BlockHeader;
+
+    return word;
+  }
+
+  static auto load_64(const std::uint8_t *data) -> std::uint64_t {
+    std::uint64_t word{0};
+    std::memcpy(&word, data, sizeof(word));
+    if (std::endian::native == std::endian::big) {
+      word = std::byteswap(word);
     }
+
+    return word;
+  }
+
+  static auto hash(const std::uint32_t word) -> std::uint32_t {
+    return (word * 0x1e35a7bdU) >> (32 - HASH_BITS);
+  }
+
+  static auto hash_fast(const std::uint32_t word) -> std::uint32_t {
+    return (word * 0x1e35a7bdU) >> (32 - FAST_HASH_BITS);
   }
 
-  auto process_huffman_block(std::uint8_t *output,
-                             const std::size_t output_size,
-                             std::size_t &produced) -> void {
-    if (this->pending_copy_length_ > 0) {
-      this->copy_backref(output, output_size, produced);
-      if (this->pending_copy_length_ > 0) {
-        return;
+  // Counts how many bytes match between two positions, up to a limit
+  static auto extend(const std::uint8_t *left, const std::uint8_t *right,
+                     const std::size_t limit) -> std::size_t {
+    std::size_t length{0};
+    while (length + 8 <= limit) {
+      const auto difference{load_64(left + length) ^ load_64(right + length)};
+      if (difference != 0) {
+        return length +
+               (static_cast<std::size_t>(std::countr_zero(difference)) / 8);
       }
+
+      length += 8;
     }
 
-    while (produced < output_size) {
-      const auto symbol{this->literal_length_tree_.decode(*this->reader_)};
-      if (symbol < 256) {
-        this->window_[this->window_position_] =
-            static_cast<std::uint8_t>(symbol);
-        this->window_position_ =
-            (this->window_position_ + 1) & DEFLATE_WINDOW_MASK;
-        if (this->bytes_written_ < DEFLATE_WINDOW_SIZE) {
-          ++this->bytes_written_;
+    while (length < limit && left[length] == right[length]) {
+      length += 1;
+    }
+
+    return length;
+  }
+
+  auto record_literal(const std::uint8_t byte) -> void {
+    this->literal_length_frequencies_[byte] += 1;
+    this->pending_literals_ += 1;
+  }
+
+  auto record_match(const std::size_t length, const std::size_t distance)
+      -> void {
+    this->literal_length_frequencies_[257 + DEFLATE_LENGTH_SLOTS[length]] += 1;
+    this->distance_frequencies_[deflate_distance_slot(distance)] += 1;
+    this->sequences_[this->sequence_count_] = {
+        .literals = this->pending_literals_,
+        .length = static_cast<std::uint16_t>(length),
+        .distance = static_cast<std::uint16_t>(distance)};
+    this->sequence_count_ += 1;
+    this->pending_literals_ = 0;
+  }
+
+  auto finish_sequences() -> void {
+    this->sequences_[this->sequence_count_] = {
+        .literals = this->pending_literals_, .length = 0, .distance = 0};
+    this->sequence_count_ += 1;
+    this->pending_literals_ = 0;
+  }
+
+  // Greedy matching against the two most recent positions sharing a hash,
+  // keeping the running state in locals as the tables could otherwise alias it
+  auto match_fast(const std::uint8_t *input, const std::size_t size,
+                  std::size_t position, const std::size_t block_end)
+      -> std::size_t {
+    auto *const table{this->head_.data()};
+    auto *const literal_length_frequencies{
+        this->literal_length_frequencies_.data()};
+    auto *const distance_frequencies{this->distance_frequencies_.data()};
+    auto *const sequences{this->sequences_.data()};
+    std::size_t sequence_count{this->sequence_count_};
+    std::uint32_t literals{this->pending_literals_};
+    const std::size_t hash_end{size < 8 ? 0 : size - 7};
+    const std::size_t match_end{std::min(block_end, hash_end)};
+    while (position < match_end && sequence_count < FAST_BLOCK_SEQUENCES) {
+      const auto word{load_32(input + position)};
+      const std::size_t bucket{static_cast<std::size_t>(hash_fast(word)) * 2};
+      const auto current{static_cast<std::uint32_t>(position)};
+      const auto first{table[bucket]};
+      const auto second{table[bucket + 1]};
+      table[bucket + 1] = first;
+      table[bucket] = current;
+      const std::size_t limit{
+          std::min(DEFLATE_MAXIMUM_MATCH_LENGTH, size - position)};
+      std::size_t best_length{0};
+      std::size_t best_distance{0};
+      // Positions are stored modulo 2^32 and the second candidate is always
+      // older than the first one, so it is only worth checking when the first
+      // one is still within the window
+      const std::uint32_t first_distance{current - first};
+      if (first_distance - 1 < DEFLATE_WINDOW_SIZE) {
+        const auto *const match{input + position - first_distance};
+        if (load_32(match) == word) {
+          best_length = 4 + extend(input + position + 4, match + 4, limit - 4);
+          best_distance = first_distance;
         }
-        output[produced++] = static_cast<std::uint8_t>(symbol);
-      } else if (symbol == 256) {
-        this->state_ = State::BlockHeader;
-        return;
-      } else if (symbol <= 285) {
-        const auto length_index{static_cast<std::size_t>(symbol - 257)};
+
+        const std::uint32_t second_distance{current - second};
+        if (best_length < std::min(FAST_NICE_LENGTH, limit) &&
+            second_distance - 1 < DEFLATE_WINDOW_SIZE) {
+          const auto *const other{input + position - second_distance};
+          if (load_32(other) == word &&
+              other[best_length] == input[position + best_length]) {
+            const std::size_t length{
+                4 + extend(input + position + 4, other + 4, limit - 4)};
+            if (length > best_length) {
+              best_length = length;
+              best_distance = second_distance;
+            }
+          }
+        }
+      }
+
+      if (best_length == 0) {
+        literal_length_frequencies[input[position]] += 1;
+        literals += 1;
+        position += 1;
+        continue;
+      }
+
+      literal_length_frequencies[257 + DEFLATE_LENGTH_SLOTS[best_length]] += 1;
+      distance_frequencies[deflate_distance_slot(best_distance)] += 1;
+      sequences[sequence_count] = {
+          .literals = literals,
+          .length = static_cast<std::uint16_t>(best_length),
+          .distance = static_cast<std::uint16_t>(best_distance)};
+      sequence_count += 1;
+      literals = 0;
+      const std::size_t end{position + best_length};
+      const std::size_t insert_end{std::min(end, hash_end)};
+      for (position += 1; position < insert_end; ++position) {
+        const std::size_t covered{
+            static_cast<std::size_t>(hash_fast(load_32(input + position))) * 2};
+        table[covered + 1] = table[covered];
+        table[covered] = static_cast<std::uint32_t>(position);
+      }
+
+      position = end;
+    }
+
+    while (position < block_end && sequence_count < FAST_BLOCK_SEQUENCES) {
+      literal_length_frequencies[input[position]] += 1;
+      literals += 1;
+      position += 1;
+    }
+
+    this->sequence_count_ = sequence_count;
+    this->pending_literals_ = literals;
+    this->finish_sequences();
+    return position;
+  }
+
+  auto insert(const std::uint8_t *input, const std::size_t position) -> void {
+    const auto slot{hash(load_32(input + position))};
+    this->previous_[position & WINDOW_MASK] = this->head_[slot];
+    this->head_[slot] = static_cast<std::uint32_t>(position);
+  }
+
+  // Walks the hash chain from the most recent position, stopping once the
+  // chain no longer moves further back in the window
+  auto find(const std::uint8_t *input, const std::size_t size,
+            const std::size_t position, std::size_t &best_distance)
+      -> std::size_t {
+    const auto &settings{
+        DEFLATE_LEVELS[static_cast<std::size_t>(this->level_)]};
+    const std::size_t limit{
+        std::min(DEFLATE_MAXIMUM_MATCH_LENGTH, size - position)};
+    const auto word{load_32(input + position)};
+    std::size_t best_length{0};
+    std::size_t candidate{this->head_[hash(word)]};
+    std::size_t previous_distance{0};
+    for (unsigned int depth = 0; depth < settings.search_depth; ++depth) {
+      const std::size_t distance{
+          static_cast<std::uint32_t>(static_cast<std::uint32_t>(position) -
+                                     static_cast<std::uint32_t>(candidate))};
+      if (distance <= previous_distance || distance > DEFLATE_WINDOW_SIZE ||
+          distance > position) {
+        break;
+      }
+
+      const auto *match{input + position - distance};
+      if ((best_length == 0 ||
+           match[best_length] == input[position + best_length]) &&
+          load_32(match) == word) {
         const std::size_t length{
-            static_cast<std::size_t>(DEFLATE_LENGTH_BASE[length_index]) +
-            static_cast<std::size_t>(
-                this->reader_->read_bits(DEFLATE_LENGTH_EXTRA[length_index]))};
-        const auto distance_symbol{this->distance_tree_.decode(*this->reader_)};
-        if (distance_symbol >= 30) {
-          throw GZIPError{"Invalid distance code"};
+            4 + extend(input + position + 4, match + 4, limit - 4)};
+        if (length > best_length) {
+          best_length = length;
+          best_distance = distance;
+          if (length >= settings.nice_length || length == limit) {
+            break;
+          }
+        }
+      }
+
+      previous_distance = distance;
+      candidate = this->previous_[candidate & WINDOW_MASK];
+    }
+
+    return best_length;
+  }
+
+  auto match_chains(const std::uint8_t *input, const std::size_t size,
+                    std::size_t position, const std::size_t block_end)
+      -> std::size_t {
+    const auto &settings{
+        DEFLATE_LEVELS[static_cast<std::size_t>(this->level_)]};
+    std::size_t previous_length{0};
+    std::size_t previous_distance{0};
+    bool previous_available{false};
+    while (position < block_end) {
+      if (size - position < 8) {
+        if (previous_available) {
+          if (previous_length >= 4) {
+            break;
+          }
+
+          this->record_literal(input[position - 1]);
+          previous_available = false;
+        }
+
+        this->record_literal(input[position]);
+        position += 1;
+        continue;
+      }
+
+      std::size_t distance{0};
+      std::size_t length{this->find(input, size, position, distance)};
+      this->insert(input, position);
+      if (length > 0 && length < 4) {
+        length = 0;
+      }
+
+      if (previous_available && previous_length >= 4 &&
+          length <= previous_length) {
+        // The match found one position earlier is at least as good
+        const std::size_t start{position - 1};
+        this->record_match(previous_length, previous_distance);
+        const std::size_t end{start + previous_length};
+        position += 1;
+        while (position < end && size - position >= 8) {
+          this->insert(input, position);
+          position += 1;
         }
-        const std::size_t distance{
-            static_cast<std::size_t>(DEFLATE_DISTANCE_BASE[distance_symbol]) +
-            static_cast<std::size_t>(this->reader_->read_bits(
-                DEFLATE_DISTANCE_EXTRA[distance_symbol]))};
-        if (distance > this->bytes_written_) {
-          throw GZIPError{"Backref distance exceeds bytes available"};
+
+        position = end;
+        previous_available = false;
+        previous_length = 0;
+        continue;
+      }
+
+      if (!settings.lazy) {
+        if (length < 4) {
+          this->record_literal(input[position]);
+          position += 1;
+          continue;
         }
-        this->pending_copy_length_ = length;
-        this->pending_copy_distance_ = distance;
-        this->copy_backref(output, output_size, produced);
-        if (this->pending_copy_length_ > 0) {
-          return;
+
+        this->record_match(length, distance);
+        const std::size_t end{position + length};
+        position += 1;
+        while (position < end && size - position >= 8) {
+          this->insert(input, position);
+          position += 1;
         }
+
+        position = end;
+        continue;
+      }
+
+      if (previous_available) {
+        this->record_literal(input[position - 1]);
+      }
+
+      if (length >= settings.nice_length) {
+        this->record_match(length, distance);
+        const std::size_t end{position + length};
+        position += 1;
+        while (position < end && size - position >= 8) {
+          this->insert(input, position);
+          position += 1;
+        }
+
+        position = end;
+        previous_available = false;
+        previous_length = 0;
+        continue;
+      }
+
+      previous_available = true;
+      previous_length = length;
+      previous_distance = distance;
+      position += 1;
+    }
+
+    if (previous_available) {
+      if (previous_length >= 4 && position - 1 + previous_length <= size) {
+        const std::size_t start{position - 1};
+        this->record_match(previous_length, previous_distance);
+        position = start + previous_length;
       } else {
-        throw GZIPError{"Invalid literal/length code"};
+        this->record_literal(input[position - 1]);
       }
     }
-  }
 
-  auto copy_backref(std::uint8_t *output, const std::size_t output_size,
-                    std::size_t &produced) -> void {
-    const auto remaining{output_size - produced};
-    const auto to_copy{std::min(this->pending_copy_length_, remaining)};
+    this->finish_sequences();
+    return position;
+  }
 
-    if (this->pending_copy_distance_ >= this->pending_copy_length_) {
-      // Source range does not overlap with the bytes about to be written
-      this->copy_backref_non_overlapping(output, produced, to_copy);
-    } else {
-      // RLE-style overlap: must propagate byte by byte
-      this->copy_backref_overlapping(output, output_size, produced);
+  auto emit_stored(DeflateBitWriter &writer, const std::uint8_t *data,
+                   std::size_t size, const bool final) -> void {
+    while (true) {
+      const std::size_t chunk{std::min(size, DEFLATE_MAXIMUM_STORED_LENGTH)};
+      const bool last{final && chunk == size};
+      writer.add(last ? 1U : 0U, 1);
+      writer.add(0, 2);
+      writer.align();
+      const std::array<std::uint8_t, 4> header{
+          {static_cast<std::uint8_t>(chunk & 0xff),
+           static_cast<std::uint8_t>((chunk >> 8) & 0xff),
+           static_cast<std::uint8_t>(~chunk & 0xff),
+           static_cast<std::uint8_t>((~chunk >> 8) & 0xff)}};
+      writer.bytes(header.data(), header.size());
+      writer.bytes(data, chunk);
+      data += chunk;
+      size -= chunk;
+      if (size == 0) {
+        break;
+      }
     }
   }
 
-  auto copy_backref_non_overlapping(std::uint8_t *output, std::size_t &produced,
-                                    const std::size_t to_copy) -> void {
-    const std::size_t source_position{(this->window_position_ +
-                                       DEFLATE_WINDOW_SIZE -
-                                       this->pending_copy_distance_) &
-                                      DEFLATE_WINDOW_MASK};
-
-    // Copy from circular window into linear output (one or two contiguous
-    // chunks depending on whether the source range wraps the window)
-    const std::size_t source_first{
-        std::min(to_copy, DEFLATE_WINDOW_SIZE - source_position)};
-    std::memcpy(output + produced, this->window_.data() + source_position,
-                source_first);
-    if (source_first < to_copy) {
-      std::memcpy(output + produced + source_first, this->window_.data(),
-                  to_copy - source_first);
-    }
-
-    // Mirror the freshly written bytes back into the circular window
-    const std::size_t dest_first{
-        std::min(to_copy, DEFLATE_WINDOW_SIZE - this->window_position_)};
-    std::memcpy(this->window_.data() + this->window_position_,
-                output + produced, dest_first);
-    if (dest_first < to_copy) {
-      std::memcpy(this->window_.data(), output + produced + dest_first,
-                  to_copy - dest_first);
-    }
-
-    produced += to_copy;
-    this->window_position_ =
-        (this->window_position_ + to_copy) & DEFLATE_WINDOW_MASK;
-    this->bytes_written_ =
-        std::min(this->bytes_written_ + to_copy, DEFLATE_WINDOW_SIZE);
-    this->pending_copy_length_ -= to_copy;
+  static auto stored_cost(const unsigned int pending_bits,
+                          const std::size_t size) -> std::uint64_t {
+    const std::size_t chunks{size == 0
+                                 ? 1
+                                 : (size + DEFLATE_MAXIMUM_STORED_LENGTH - 1) /
+                                       DEFLATE_MAXIMUM_STORED_LENGTH};
+    const std::uint64_t first_padding{(8 - ((pending_bits + 3) % 8)) % 8};
+    return 3 + first_padding + 32 + ((chunks - 1) * 40) +
+           (static_cast<std::uint64_t>(size) * 8);
   }
 
-  auto copy_backref_overlapping(std::uint8_t *output,
-                                const std::size_t output_size,
-                                std::size_t &produced) -> void {
-    std::size_t source_position{(this->window_position_ + DEFLATE_WINDOW_SIZE -
-                                 this->pending_copy_distance_) &
-                                DEFLATE_WINDOW_MASK};
-    while (this->pending_copy_length_ > 0 && produced < output_size) {
-      const auto byte{this->window_[source_position]};
-      this->window_[this->window_position_] = byte;
-      this->window_position_ =
-          (this->window_position_ + 1) & DEFLATE_WINDOW_MASK;
-      source_position = (source_position + 1) & DEFLATE_WINDOW_MASK;
-      if (this->bytes_written_ < DEFLATE_WINDOW_SIZE) {
-        ++this->bytes_written_;
+  // Works on a local copy of the writer so that its state can live in
+  // registers instead of memory
+  auto emit_symbols(DeflateBitWriter &destination, const std::uint8_t *data,
+                    const std::uint8_t *literal_length_lengths,
+                    const std::uint16_t *literal_length_codes,
+                    const std::uint8_t *distance_lengths,
+                    const std::uint16_t *distance_codes) -> void {
+    DeflateBitWriter writer{destination};
+    const auto *literal{data};
+    for (std::size_t index = 0; index < this->sequence_count_; ++index) {
+      const auto &sequence{this->sequences_[index]};
+      // Three codewords of at most 15 bits always fit next to the at most seven
+      // bits that a flush leaves in the buffer
+      std::uint32_t count{0};
+      while (count + 3 <= sequence.literals) {
+        writer.add(literal_length_codes[literal[0]],
+                   literal_length_lengths[literal[0]]);
+        writer.add(literal_length_codes[literal[1]],
+                   literal_length_lengths[literal[1]]);
+        writer.add(literal_length_codes[literal[2]],
+                   literal_length_lengths[literal[2]]);
+        writer.flush();
+        literal += 3;
+        count += 3;
+      }
+
+      while (count < sequence.literals) {
+        writer.add(literal_length_codes[*literal],
+                   literal_length_lengths[*literal]);
+        writer.flush();
+        literal += 1;
+        count += 1;
       }
-      output[produced++] = byte;
-      --this->pending_copy_length_;
+
+      if (sequence.length == 0) {
+        continue;
+      }
+
+      const std::size_t length_slot{DEFLATE_LENGTH_SLOTS[sequence.length]};
+      const std::size_t length_symbol{257 + length_slot};
+      writer.add(literal_length_codes[length_symbol],
+                 literal_length_lengths[length_symbol]);
+      writer.add(static_cast<std::uint32_t>(sequence.length -
+                                            INFLATE_LENGTH_BASE[length_slot]),
+                 INFLATE_LENGTH_EXTRA_BITS[length_slot]);
+      writer.flush();
+      const auto distance_slot{deflate_distance_slot(sequence.distance)};
+      writer.add(distance_codes[distance_slot],
+                 distance_lengths[distance_slot]);
+      writer.add(static_cast<std::uint32_t>(
+                     sequence.distance - INFLATE_DISTANCE_BASE[distance_slot]),
+                 INFLATE_DISTANCE_EXTRA_BITS[distance_slot]);
+      writer.flush();
+      literal += sequence.length;
     }
+
+    writer.add(literal_length_codes[DEFLATE_END_OF_BLOCK],
+               literal_length_lengths[DEFLATE_END_OF_BLOCK]);
+    writer.flush();
+    destination = writer;
   }
 
-  auto emit(const std::uint8_t byte, std::uint8_t *output,
-            const std::size_t output_size, std::size_t &produced) -> bool {
-    this->window_[this->window_position_] = byte;
-    this->window_position_ = (this->window_position_ + 1) & DEFLATE_WINDOW_MASK;
-    if (this->bytes_written_ < DEFLATE_WINDOW_SIZE) {
-      ++this->bytes_written_;
+  // Emits the block with whichever of the stored, fixed, and dynamic
+  // encodings of RFC 1951 section 3.2.3 is the smallest
+  auto emit_block(DeflateBitWriter &writer, const std::uint8_t *data,
+                  const std::size_t size, const bool final) -> void {
+    auto &frequencies{this->literal_length_frequencies_};
+    frequencies[DEFLATE_END_OF_BLOCK] = 1;
+
+    std::uint64_t extra_bits{0};
+    for (std::size_t slot = 0; slot < INFLATE_LENGTH_BASE.size(); ++slot) {
+      extra_bits += static_cast<std::uint64_t>(frequencies[257 + slot]) *
+                    INFLATE_LENGTH_EXTRA_BITS[slot];
     }
-    if (produced < output_size) {
-      output[produced++] = byte;
-      return true;
+
+    for (std::size_t slot = 0; slot < INFLATE_DISTANCE_BASE.size(); ++slot) {
+      extra_bits +=
+          static_cast<std::uint64_t>(this->distance_frequencies_[slot]) *
+          INFLATE_DISTANCE_EXTRA_BITS[slot];
+    }
+
+    this->code_builder_.lengths(frequencies.data(), 286,
+                                INFLATE_MAXIMUM_CODEWORD_LENGTH,
+                                this->literal_length_lengths_.data());
+    this->code_builder_.lengths(this->distance_frequencies_.data(), 30,
+                                INFLATE_MAXIMUM_CODEWORD_LENGTH,
+                                this->distance_lengths_.data());
+
+    std::size_t literal_length_count{286};
+    while (literal_length_count > 257 &&
+           this->literal_length_lengths_[literal_length_count - 1] == 0) {
+      literal_length_count -= 1;
+    }
+
+    std::size_t distance_count{30};
+    while (distance_count > 1 &&
+           this->distance_lengths_[distance_count - 1] == 0) {
+      distance_count -= 1;
+    }
+
+    std::array<std::uint8_t,
+               INFLATE_LITERAL_LENGTH_SYMBOLS + INFLATE_DISTANCE_SYMBOLS>
+        all_lengths{};
+    std::memcpy(all_lengths.data(), this->literal_length_lengths_.data(),
+                literal_length_count);
+    std::memcpy(all_lengths.data() + literal_length_count,
+                this->distance_lengths_.data(), distance_count);
+    this->run_.encode(all_lengths.data(),
+                      literal_length_count + distance_count);
+
+    std::array<std::uint32_t, INFLATE_CODE_LENGTH_SYMBOLS>
+        code_length_frequencies{};
+    for (std::size_t index = 0; index < this->run_.size; ++index) {
+      code_length_frequencies[this->run_.symbols[index]] += 1;
+    }
+
+    std::array<std::uint8_t, INFLATE_CODE_LENGTH_SYMBOLS> code_length_lengths{};
+    this->code_builder_.lengths(code_length_frequencies.data(),
+                                INFLATE_CODE_LENGTH_SYMBOLS, 7,
+                                code_length_lengths.data());
+    std::size_t code_length_count{INFLATE_CODE_LENGTH_SYMBOLS};
+    while (
+        code_length_count > 4 &&
+        code_length_lengths[INFLATE_CODE_LENGTH_ORDER[code_length_count - 1]] ==
+            0) {
+      code_length_count -= 1;
     }
-    return false;
-  }
 
-  BitReader *reader_;
-  State state_{State::BlockHeader};
-  bool final_block_{false};
-  bool stream_ended_{false};
+    std::uint64_t dynamic_bits{17 + (3 * code_length_count) + extra_bits};
+    for (std::size_t symbol = 0; symbol < INFLATE_CODE_LENGTH_SYMBOLS;
+         ++symbol) {
+      dynamic_bits +=
+          static_cast<std::uint64_t>(code_length_frequencies[symbol]) *
+          (code_length_lengths[symbol] +
+           DEFLATE_CODE_LENGTH_EXTRA_BITS[symbol]);
+    }
 
-  std::uint16_t stored_remaining_{0};
+    std::uint64_t fixed_bits{3 + extra_bits};
+    for (std::size_t symbol = 0; symbol < 286; ++symbol) {
+      dynamic_bits += static_cast<std::uint64_t>(frequencies[symbol]) *
+                      this->literal_length_lengths_[symbol];
+      fixed_bits += static_cast<std::uint64_t>(frequencies[symbol]) *
+                    this->fixed_.literal_length_lengths[symbol];
+    }
 
-  HuffmanDecoder literal_length_tree_{};
-  HuffmanDecoder distance_tree_{};
+    for (std::size_t symbol = 0; symbol < 30; ++symbol) {
+      dynamic_bits +=
+          static_cast<std::uint64_t>(this->distance_frequencies_[symbol]) *
+          this->distance_lengths_[symbol];
+      fixed_bits +=
+          static_cast<std::uint64_t>(this->distance_frequencies_[symbol]) * 5;
+    }
 
-  std::size_t pending_copy_length_{0};
-  std::size_t pending_copy_distance_{0};
+    const auto stored_bits{stored_cost(writer.pending_bits(), size)};
+    if (stored_bits <= fixed_bits && stored_bits <= dynamic_bits) {
+      this->emit_stored(writer, data, size, final);
+      return;
+    }
+
+    if (fixed_bits <= dynamic_bits) {
+      writer.add(final ? 1U : 0U, 1);
+      writer.add(1, 2);
+      writer.flush();
+      this->emit_symbols(writer, data,
+                         this->fixed_.literal_length_lengths.data(),
+                         this->fixed_.literal_length_codes.data(),
+                         this->fixed_.distance_lengths.data(),
+                         this->fixed_.distance_codes.data());
+      return;
+    }
+
+    writer.add(final ? 1U : 0U, 1);
+    writer.add(2, 2);
+    writer.add(static_cast<std::uint32_t>(literal_length_count - 257), 5);
+    writer.add(static_cast<std::uint32_t>(distance_count - 1), 5);
+    writer.add(static_cast<std::uint32_t>(code_length_count - 4), 4);
+    writer.flush();
+    for (std::size_t index = 0; index < code_length_count; ++index) {
+      writer.add(code_length_lengths[INFLATE_CODE_LENGTH_ORDER[index]], 3);
+      writer.flush();
+    }
+
+    std::array<std::uint16_t, INFLATE_CODE_LENGTH_SYMBOLS> code_length_codes{};
+    deflate_canonical_codes(code_length_lengths.data(),
+                            INFLATE_CODE_LENGTH_SYMBOLS,
+                            code_length_codes.data());
+    for (std::size_t index = 0; index < this->run_.size; ++index) {
+      const auto symbol{this->run_.symbols[index]};
+      writer.add(code_length_codes[symbol], code_length_lengths[symbol]);
+      writer.add(this->run_.extra[index],
+                 DEFLATE_CODE_LENGTH_EXTRA_BITS[symbol]);
+      writer.flush();
+    }
+
+    deflate_canonical_codes(this->literal_length_lengths_.data(),
+                            INFLATE_LITERAL_LENGTH_SYMBOLS,
+                            this->literal_length_codes_.data());
+    deflate_canonical_codes(this->distance_lengths_.data(),
+                            INFLATE_DISTANCE_SYMBOLS,
+                            this->distance_codes_.data());
+    this->emit_symbols(writer, data, this->literal_length_lengths_.data(),
+                       this->literal_length_codes_.data(),
+                       this->distance_lengths_.data(),
+                       this->distance_codes_.data());
+  }
 
-  std::array<std::uint8_t, DEFLATE_WINDOW_SIZE> window_{};
-  std::size_t window_position_{0};
-  // Bytes written into the sliding window since the last reset, capped at
-  // DEFLATE_WINDOW_SIZE. Used to reject back-references whose distance
-  // exceeds the data we have actually produced for the current member
-  std::size_t bytes_written_{0};
+  int level_;
+  std::vector<DeflateSequence> sequences_;
+  std::size_t sequence_count_{0};
+  std::uint32_t pending_literals_{0};
+  std::vector<std::uint32_t> head_;
+  std::vector<std::uint32_t> previous_;
+  std::array<std::uint32_t, INFLATE_LITERAL_LENGTH_SYMBOLS>
+      literal_length_frequencies_{};
+  std::array<std::uint32_t, INFLATE_DISTANCE_SYMBOLS> distance_frequencies_{};
+  std::array<std::uint8_t, INFLATE_LITERAL_LENGTH_SYMBOLS>
+      literal_length_lengths_{};
+  std::array<std::uint16_t, INFLATE_LITERAL_LENGTH_SYMBOLS>
+      literal_length_codes_{};
+  std::array<std::uint8_t, INFLATE_DISTANCE_SYMBOLS> distance_lengths_{};
+  std::array<std::uint16_t, INFLATE_DISTANCE_SYMBOLS> distance_codes_{};
+  DeflateCodeBuilder code_builder_;
+  DeflateCodeLengthRun run_;
+  DeflateFixedCodes fixed_;
 };
 
 } // namespace sourcemeta::core
diff --git a/vendor/core/src/core/gzip/gzip.cc b/vendor/core/src/core/gzip/gzip.cc
index 1399880b..7943cbf9 100644
--- a/vendor/core/src/core/gzip/gzip.cc
+++ b/vendor/core/src/core/gzip/gzip.cc
@@ -1,153 +1,138 @@
 #include <sourcemeta/core/gzip.h>
 
-extern "C" {
-#include <libdeflate.h>
-}
+#include "deflate.h"
+#include "inflate.h"
+
+#include <sourcemeta/core/crypto.h>
 
-#include <algorithm> // std::min
-#include <memory>    // std::unique_ptr
+#include <algorithm>   // std::min
+#include <cstddef>     // std::size_t
+#include <cstdint>     // std::uint8_t, std::uint32_t
+#include <memory>      // std::make_unique, std::make_unique_for_overwrite
+#include <string>      // std::string
+#include <string_view> // std::string_view
 
 namespace sourcemeta::core {
 
+namespace {
+
+// RFC 1951 cannot expand data by more than this factor, which bounds how far
+// the size recorded in a trailer can be trusted as a first capacity guess
+constexpr std::size_t MAXIMUM_EXPANSION{1032};
+
+constexpr std::size_t GZIP_HEADER_SIZE{10};
+constexpr std::size_t GZIP_TRAILER_SIZE{8};
+
+auto initial_capacity(const std::uint8_t *input, const std::size_t size,
+                      const std::size_t output_hint,
+                      const std::size_t maximum_size) -> std::size_t {
+  if (output_hint > 0) {
+    return std::min(output_hint, maximum_size);
+  }
+
+  // The last four bytes of a single member input record its size modulo 2^32
+  if (size >= 18) {
+    const auto recorded{static_cast<std::size_t>(input[size - 4]) |
+                        (static_cast<std::size_t>(input[size - 3]) << 8) |
+                        (static_cast<std::size_t>(input[size - 2]) << 16) |
+                        (static_cast<std::size_t>(input[size - 1]) << 24)};
+    const auto bound{size > maximum_size / MAXIMUM_EXPANSION
+                         ? maximum_size
+                         : size * MAXIMUM_EXPANSION};
+    return std::min({recorded, bound, maximum_size});
+  }
+
+  return std::min(size, maximum_size);
+}
+
+auto store_little_endian(std::uint8_t *destination, const std::uint32_t value)
+    -> void {
+  destination[0] = static_cast<std::uint8_t>(value & 0xff);
+  destination[1] = static_cast<std::uint8_t>((value >> 8) & 0xff);
+  destination[2] = static_cast<std::uint8_t>((value >> 16) & 0xff);
+  destination[3] = static_cast<std::uint8_t>((value >> 24) & 0xff);
+}
+
+} // namespace
+
 auto gzip(const std::uint8_t *input, const std::size_t size, const int level)
     -> std::string {
-  std::unique_ptr<libdeflate_compressor, decltype(&libdeflate_free_compressor)>
-      compressor{libdeflate_alloc_compressor(level),
-                 libdeflate_free_compressor};
-  if (!compressor) {
-    throw GZIPError{"Could not allocate compressor"};
+  if (level < 0 || level > 12) {
+    throw GZIPError{"Invalid compression level"};
   }
 
-  const auto max_size{libdeflate_gzip_compress_bound(compressor.get(), size)};
+  const auto encoder{std::make_unique<DeflateEncoder>(level, size)};
   std::string output;
-  std::size_t actual_size{0};
-  // libdeflate overwrites the whole bound, so leaving the buffer uninitialised
-  // avoids zero-filling multi-megabyte allocations that are immediately
-  // discarded
   output.resize_and_overwrite(
-      max_size,
-      [&](char *const buffer, const std::size_t capacity) -> std::size_t {
-        actual_size = libdeflate_gzip_compress(compressor.get(), input, size,
-                                               buffer, capacity);
-        return capacity;
+      GZIP_HEADER_SIZE + DeflateEncoder::bound(size) + GZIP_TRAILER_SIZE,
+      [&](char *const buffer, const std::size_t) -> std::size_t {
+        auto *const data{reinterpret_cast<std::uint8_t *>(buffer)};
+        // RFC 1952 section 2.3.1: no optional fields, no modification time,
+        // and an unknown operating system
+        data[0] = 0x1f;
+        data[1] = 0x8b;
+        data[2] = 0x08;
+        data[3] = 0x00;
+        store_little_endian(data + 4, 0);
+        data[8] = level <= 1 ? 0x04 : (level >= 9 ? 0x02 : 0x00);
+        data[9] = 0xff;
+        const auto written{
+            encoder->compress(input, size, data + GZIP_HEADER_SIZE)};
+        auto *const trailer{data + GZIP_HEADER_SIZE + written};
+        store_little_endian(trailer,
+                            crc32(std::string_view{
+                                reinterpret_cast<const char *>(input), size}));
+        store_little_endian(trailer + 4, static_cast<std::uint32_t>(size));
+        return GZIP_HEADER_SIZE + written + GZIP_TRAILER_SIZE;
       });
 
-  if (actual_size == 0) {
-    throw GZIPError{"Could not compress input"};
-  }
-
-  output.resize(actual_size);
   return output;
 }
 
 auto gunzip(const std::uint8_t *input, const std::size_t size,
             const std::size_t output_hint, const std::size_t maximum_size)
     -> std::string {
-  std::unique_ptr<libdeflate_decompressor,
-                  decltype(&libdeflate_free_decompressor)>
-      decompressor{libdeflate_alloc_decompressor(),
-                   libdeflate_free_decompressor};
-  if (!decompressor) {
-    throw GZIPError{"Could not allocate decompressor"};
-  }
-
+  const auto decoder{std::make_unique_for_overwrite<InflateDecoder>()};
+  InflateBuffers buffers{.input_next = input,
+                         .input_end = input + size,
+                         .input_final = true,
+                         .output_begin = nullptr,
+                         .output_next = nullptr,
+                         .output_end = nullptr};
   std::string output;
-  // Bound the very first allocation too, so a hint or the size heuristic cannot
-  // exceed the cap before the loop has a chance to reject the input. The size
-  // heuristic is guarded so that the multiplication cannot overflow before the
-  // clamp, since the cap is caller-controlled
-  std::size_t capacity{0};
-  if (output_hint > 0) {
-    capacity = std::min(output_hint, maximum_size);
-  } else if (size > maximum_size / 4) {
-    capacity = maximum_size;
-  } else {
-    capacity = size * 4;
-  }
-
-  // Decompress the first member. Every gzip stream has at least one member, so
-  // a failure here is a real error rather than trailing data
-  std::size_t total_in{0};
-  std::size_t total_out{0};
-  for (;;) {
-    std::size_t member_in{0};
-    std::size_t member_out{0};
-    auto result{LIBDEFLATE_BAD_DATA};
-    // libdeflate writes only the decompressed bytes, so leaving the buffer
-    // uninitialised avoids zero-filling multi-megabyte allocations on every
-    // retry of the doubling loop
+  std::size_t capacity{
+      initial_capacity(input, size, output_hint, maximum_size)};
+  std::size_t position{0};
+  while (true) {
+    // Growing keeps the bytes decoded so far, and leaving the rest
+    // uninitialised avoids zero-filling memory that is about to be written
     output.resize_and_overwrite(
         capacity,
-        [&](char *const buffer, const std::size_t buffer_size) -> std::size_t {
-          result = libdeflate_gzip_decompress_ex(decompressor.get(), input,
-                                                 size, buffer, buffer_size,
-                                                 &member_in, &member_out);
-          return buffer_size;
-        });
-
-    if (result == LIBDEFLATE_SUCCESS) {
-      total_in = member_in;
-      total_out = member_out;
+        [](char *, const std::size_t count) -> std::size_t { return count; });
+    auto *const begin{reinterpret_cast<std::uint8_t *>(output.data())};
+    buffers.output_begin = begin;
+    buffers.output_next = begin + position;
+    buffers.output_end = begin + capacity;
+    const auto status{decoder->decode(buffers)};
+    position = static_cast<std::size_t>(buffers.output_next - begin);
+    if (status == InflateStatus::Done) {
       break;
     }
 
-    if (result == LIBDEFLATE_INSUFFICIENT_SPACE) {
-      if (capacity >= maximum_size) {
-        throw GZIPError{"Decompressed output exceeds the maximum allowed size"};
-      }
-
-      // Double without overflowing: capacity is below the cap here, so doubling
-      // only runs when the result still fits under it
-      capacity = (capacity > maximum_size / 2) ? maximum_size : capacity * 2;
-      continue;
+    // The whole input is available upfront, so the decoder only ever stops
+    // early because the output is full
+    if (capacity >= maximum_size) {
+      throw GZIPError{"Decompressed output exceeds the maximum allowed size"};
     }
 
-    throw GZIPError{"Could not decompress input"};
-  }
-
-  // RFC 1952 Section 2.2 permits concatenated members. Like gzip(1) and the
-  // streaming decoder, decompress every subsequent member and silently ignore
-  // trailing data that does not begin a new member, so `resize` here preserves
-  // the members already decoded
-  while (total_in < size) {
-    if (size - total_in < 2 || input[total_in] != 0x1F ||
-        input[total_in + 1] != 0x8B) {
-      break;
+    if (capacity == 0) {
+      capacity = std::min(std::size_t{4096}, maximum_size);
+    } else {
+      capacity = capacity > maximum_size / 2 ? maximum_size : capacity * 2;
     }
-
-    std::size_t member_in{0};
-    std::size_t member_out{0};
-    for (;;) {
-      const auto result{libdeflate_gzip_decompress_ex(
-          decompressor.get(), input + total_in, size - total_in,
-          output.data() + total_out, output.size() - total_out, &member_in,
-          &member_out)};
-
-      if (result == LIBDEFLATE_SUCCESS) {
-        break;
-      }
-
-      if (result == LIBDEFLATE_INSUFFICIENT_SPACE) {
-        if (output.size() >= maximum_size) {
-          throw GZIPError{
-              "Decompressed output exceeds the maximum allowed size"};
-        }
-
-        output.resize((output.size() > maximum_size / 2) ? maximum_size
-                                                         : output.size() * 2);
-        continue;
-      }
-
-      // A run that begins with the gzip magic but fails to decode is a corrupt
-      // member, not trailing data, so it is a real error
-      throw GZIPError{"Could not decompress input"};
-    }
-
-    total_in += member_in;
-    total_out += member_out;
   }
 
-  output.resize(total_out);
+  output.resize(position);
   return output;
 }
 
diff --git a/vendor/core/src/core/gzip/huffman.h b/vendor/core/src/core/gzip/huffman.h
deleted file mode 100644
index 79a6cf07..00000000
--- a/vendor/core/src/core/gzip/huffman.h
+++ /dev/null
@@ -1,168 +0,0 @@
-#ifndef SOURCEMETA_CORE_GZIP_HUFFMAN_H_
-#define SOURCEMETA_CORE_GZIP_HUFFMAN_H_
-
-#include "bit_reader.h"
-
-#include <sourcemeta/core/gzip_error.h>
-
-#include <algorithm> // std::ranges::fill
-#include <array>     // std::array
-#include <cassert>   // assert
-#include <cstddef>   // std::size_t
-#include <cstdint>   // std::uint8_t, std::uint16_t
-
-namespace sourcemeta::core {
-
-// Maximum Huffman code length per RFC 1951 section 3.2.7
-inline constexpr unsigned int MAX_HUFFMAN_BITS{15};
-
-// Largest alphabet is the literal/length alphabet (288 symbols) per RFC 1951
-// section 3.2.5
-inline constexpr std::size_t MAX_HUFFMAN_SYMBOLS{288};
-
-class HuffmanDecoder {
-public:
-  // Primary lookup table covering all codes of length <= LUT_BITS. Misses
-  // fall back to the canonical-puff traversal for codes of length 10..15
-  static constexpr unsigned int LUT_BITS{9};
-  static constexpr std::size_t LUT_SIZE{1U << LUT_BITS};
-
-  HuffmanDecoder() = default;
-
-  // The fixed distance tree of RFC 1951 section 3.2.6 is intentionally
-  // incomplete (30 codes of length five over a 32-slot space), so the
-  // completeness check is suppressed for it and enforced everywhere else
-  auto build(const std::uint8_t *lengths, const std::size_t length_count,
-             const bool allow_incomplete = false) -> void {
-    std::ranges::fill(this->count_, std::uint16_t{0});
-    std::ranges::fill(this->lut_, std::uint16_t{0});
-
-    for (std::size_t symbol = 0; symbol < length_count; ++symbol) {
-      // The fixed trees use lengths five to nine, the code length tree
-      // reads three bit values, and the dynamic trees copy code length
-      // symbols below sixteen, so no caller can supply a longer length
-      assert(lengths[symbol] <= MAX_HUFFMAN_BITS);
-      this->count_[lengths[symbol]]++;
-    }
-
-    if (this->count_[0] == length_count) {
-      return;
-    }
-
-    // Verify the alphabet is complete or single-symbol per RFC 1951
-    int left{1};
-    for (unsigned int bits = 1; bits <= MAX_HUFFMAN_BITS; ++bits) {
-      left <<= 1;
-      left -= this->count_[bits];
-      if (left < 0) {
-        throw GZIPError{"Over-subscribed Huffman code"};
-      }
-    }
-
-    // Reject incomplete codes, matching zlib and puff. RFC 1951 sanctions
-    // incompleteness only for the single-code case (a tree built from one
-    // used code of length one), where every length is either zero or one
-    if (left > 0 && !allow_incomplete &&
-        length_count != static_cast<std::size_t>(this->count_[0]) +
-                            static_cast<std::size_t>(this->count_[1])) {
-      throw GZIPError{"Incomplete Huffman code"};
-    }
-
-    std::array<std::uint16_t, MAX_HUFFMAN_BITS + 1> offsets{};
-    offsets[1] = 0;
-    for (unsigned int bits = 1; bits < MAX_HUFFMAN_BITS; ++bits) {
-      offsets[bits + 1] =
-          static_cast<std::uint16_t>(offsets[bits] + this->count_[bits]);
-    }
-
-    for (std::size_t symbol = 0; symbol < length_count; ++symbol) {
-      if (lengths[symbol] != 0) {
-        this->symbols_[offsets[lengths[symbol]]++] =
-            static_cast<std::uint16_t>(symbol);
-      }
-    }
-
-    // Build the fast-path LUT. Each entry packs (symbol << 4) | length;
-    // a value of 0 means "no short code, fall back". Codes longer than
-    // LUT_BITS leave their LUT entries at 0
-    std::array<std::uint32_t, MAX_HUFFMAN_BITS + 1> next_code{};
-    next_code[1] = 0;
-    for (unsigned int bits = 2; bits <= MAX_HUFFMAN_BITS; ++bits) {
-      next_code[bits] = (next_code[bits - 1] + this->count_[bits - 1]) << 1U;
-    }
-
-    std::size_t symbol_index{0};
-    for (unsigned int code_length = 1; code_length <= MAX_HUFFMAN_BITS;
-         ++code_length) {
-      for (unsigned int k = 0; k < this->count_[code_length]; ++k) {
-        const auto symbol{this->symbols_[symbol_index]};
-        if (code_length <= LUT_BITS) {
-          const auto code{next_code[code_length]};
-          const auto lsb_key{reverse_bits(code, code_length)};
-          const auto entry{static_cast<std::uint16_t>(
-              static_cast<std::uint16_t>(code_length) |
-              static_cast<std::uint16_t>(symbol << 4U))};
-          const std::uint32_t stride{1U << code_length};
-          for (std::uint32_t slot = lsb_key; slot < LUT_SIZE; slot += stride) {
-            this->lut_[slot] = entry;
-          }
-        }
-        ++next_code[code_length];
-        ++symbol_index;
-      }
-    }
-  }
-
-  auto decode(BitReader &reader) const -> std::uint16_t {
-    const auto key{reader.peek_bits(LUT_BITS)};
-    const auto entry{this->lut_[key]};
-    if (entry != 0) {
-      const unsigned int length{entry & 0xfU};
-      reader.consume_bits(length);
-      return static_cast<std::uint16_t>(entry >> 4U);
-    }
-    return this->decode_long(reader);
-  }
-
-private:
-  auto decode_long(BitReader &reader) const -> std::uint16_t {
-    std::uint32_t bits{reader.peek_bits(MAX_HUFFMAN_BITS)};
-    int code{0};
-    int first{0};
-    int index{0};
-    for (unsigned int length = 1; length <= MAX_HUFFMAN_BITS; ++length) {
-      code |= static_cast<int>(bits & 1U);
-      bits >>= 1U;
-      const auto entries{static_cast<int>(this->count_[length])};
-      if (code - entries < first) {
-        const auto position{static_cast<std::size_t>(index) +
-                            static_cast<std::size_t>(code - first)};
-        reader.consume_bits(length);
-        return this->symbols_[position];
-      }
-      index += entries;
-      first = (first + entries) << 1;
-      code <<= 1;
-    }
-    throw GZIPError{"Invalid Huffman code"};
-  }
-
-  static auto reverse_bits(std::uint32_t value, const unsigned int length)
-      -> std::uint32_t {
-    std::uint32_t result{0};
-    for (unsigned int index = 0; index < length; ++index) {
-      if ((value & (1U << (length - 1 - index))) != 0U) {
-        result |= (1U << index);
-      }
-    }
-    return result;
-  }
-
-  std::array<std::uint16_t, MAX_HUFFMAN_BITS + 1> count_{};
-  std::array<std::uint16_t, MAX_HUFFMAN_SYMBOLS> symbols_{};
-  std::array<std::uint16_t, LUT_SIZE> lut_{};
-};
-
-} // namespace sourcemeta::core
-
-#endif
diff --git a/vendor/core/src/core/gzip/include/sourcemeta/core/gzip.h b/vendor/core/src/core/gzip/include/sourcemeta/core/gzip.h
index fd7f202b..1c2b553f 100644
--- a/vendor/core/src/core/gzip/include/sourcemeta/core/gzip.h
+++ b/vendor/core/src/core/gzip/include/sourcemeta/core/gzip.h
@@ -27,7 +27,8 @@ namespace sourcemeta::core {
 
 /// @ingroup gzip
 /// Compress a byte buffer using the GZIP format (RFC 1952). An optional
-/// compression level from 0 to 12 trades speed for ratio. For example:
+/// compression level from 0 to 12 trades speed for ratio, and any other level
+/// throws. For example:
 ///
 /// ```cpp
 /// #include <sourcemeta/core/gzip.h>
@@ -46,7 +47,9 @@ auto SOURCEMETA_CORE_GZIP_EXPORT gzip(const std::uint8_t *input,
 /// bounded by a maximum size (256 MiB by default) so that a highly compressed
 /// input cannot exhaust memory, and decompressing beyond it throws. Every
 /// concatenated member is decoded and any trailing data that does not begin a
-/// new member is ignored, matching gzip(1). For example:
+/// new member is ignored, matching gzip(1). A member starts with the two gzip
+/// identification bytes and must then be valid. Decompression behaves exactly
+/// like the streaming decompression of the stream buffer. For example:
 ///
 /// ```cpp
 /// #include <sourcemeta/core/gzip.h>
diff --git a/vendor/core/src/core/gzip/inflate.h b/vendor/core/src/core/gzip/inflate.h
new file mode 100644
index 00000000..046a9528
--- /dev/null
+++ b/vendor/core/src/core/gzip/inflate.h
@@ -0,0 +1,1680 @@
+#ifndef SOURCEMETA_CORE_GZIP_INFLATE_H_
+#define SOURCEMETA_CORE_GZIP_INFLATE_H_
+
+#include <sourcemeta/core/crypto.h>
+#include <sourcemeta/core/gzip_error.h>
+
+#include <algorithm> // std::min
+#include <array>     // std::array
+#include <bit>       // std::endian, std::byteswap, std::countl_zero
+#include <cstddef>   // std::size_t
+#include <cstdint> // std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t
+#include <cstring> // std::memcpy, std::memset, std::memchr
+#include <string_view> // std::string_view
+#include <utility>     // std::cmp_greater
+
+namespace sourcemeta::core {
+
+// A decode table entry packs the symbol value in the upper 16 bits, flags in
+// bits 13 to 15 and 5 to 7, the number of codeword bits in bits 8 to 12, and
+// the number of codeword and extra bits to consume in the lowest 5 bits
+inline constexpr std::uint32_t INFLATE_ENTRY_END_OF_BLOCK{0x20};
+inline constexpr std::uint32_t INFLATE_ENTRY_EXCEPTIONAL{0x40};
+inline constexpr std::uint32_t INFLATE_ENTRY_LITERAL{0x80};
+inline constexpr std::uint32_t INFLATE_ENTRY_SUBTABLE{0x2000};
+inline constexpr std::uint32_t INFLATE_ENTRY_INVALID_CODE{0x4000};
+inline constexpr std::uint32_t INFLATE_ENTRY_INVALID_SYMBOL{0x8000};
+
+// RFC 1951 section 3.2.7 limits every codeword to 15 bits
+inline constexpr unsigned int INFLATE_MAXIMUM_CODEWORD_LENGTH{15};
+
+// Codes longer than the primary index continue into fixed size subtables. The
+// number of subtables is bounded by the number of symbols, as every subtable
+// holds at least one codeword
+inline constexpr unsigned int INFLATE_LITERAL_LENGTH_TABLE_BITS{11};
+inline constexpr unsigned int INFLATE_DISTANCE_TABLE_BITS{8};
+inline constexpr unsigned int INFLATE_CODE_LENGTH_TABLE_BITS{7};
+inline constexpr std::size_t INFLATE_LITERAL_LENGTH_SYMBOLS{288};
+inline constexpr std::size_t INFLATE_DISTANCE_SYMBOLS{32};
+inline constexpr std::size_t INFLATE_CODE_LENGTH_SYMBOLS{19};
+inline constexpr std::size_t INFLATE_LITERAL_LENGTH_TABLE_SIZE{
+    (std::size_t{1} << INFLATE_LITERAL_LENGTH_TABLE_BITS) +
+    (INFLATE_LITERAL_LENGTH_SYMBOLS *
+     (std::size_t{1} << (INFLATE_MAXIMUM_CODEWORD_LENGTH -
+                         INFLATE_LITERAL_LENGTH_TABLE_BITS)))};
+inline constexpr std::size_t INFLATE_DISTANCE_TABLE_SIZE{
+    (std::size_t{1} << INFLATE_DISTANCE_TABLE_BITS) +
+    (INFLATE_DISTANCE_SYMBOLS *
+     (std::size_t{1} << (INFLATE_MAXIMUM_CODEWORD_LENGTH -
+                         INFLATE_DISTANCE_TABLE_BITS)))};
+inline constexpr std::size_t INFLATE_CODE_LENGTH_TABLE_SIZE{
+    std::size_t{1} << INFLATE_CODE_LENGTH_TABLE_BITS};
+
+// RFC 1951 section 3.2.5
+inline constexpr std::array<std::uint16_t, 29> INFLATE_LENGTH_BASE{
+    {3,  4,  5,  6,  7,  8,  9,  10, 11,  13,  15,  17,  19,  23, 27,
+     31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258}};
+inline constexpr std::array<std::uint8_t, 29> INFLATE_LENGTH_EXTRA_BITS{
+    {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2,
+     2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0}};
+inline constexpr std::array<std::uint16_t, 30> INFLATE_DISTANCE_BASE{
+    {1,    2,    3,    4,    5,    7,    9,    13,    17,    25,
+     33,   49,   65,   97,   129,  193,  257,  385,   513,   769,
+     1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577}};
+inline constexpr std::array<std::uint8_t, 30> INFLATE_DISTANCE_EXTRA_BITS{
+    {0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
+     6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}};
+
+// RFC 1951 section 3.2.7
+inline constexpr std::array<std::uint8_t, 19> INFLATE_CODE_LENGTH_ORDER{
+    {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}};
+
+// The part of the decode table entry of every symbol that does not depend on
+// its codeword, packing the literal byte, or the base and the number of extra
+// bits of a length or a distance as per RFC 1951 section 3.2.5. Symbols 286
+// and 287 of the literal/length alphabet and symbols 30 and 31 of the distance
+// alphabet never occur in compressed data as per RFC 1951 section 3.2.6
+inline constexpr std::array<std::uint32_t, INFLATE_LITERAL_LENGTH_SYMBOLS>
+    INFLATE_LITERAL_LENGTH_RESULTS{
+        {0x00000080U,
+         0x00010080U,
+         0x00020080U,
+         0x00030080U,
+         0x00040080U,
+         0x00050080U,
+         0x00060080U,
+         0x00070080U,
+         0x00080080U,
+         0x00090080U,
+         0x000A0080U,
+         0x000B0080U,
+         0x000C0080U,
+         0x000D0080U,
+         0x000E0080U,
+         0x000F0080U,
+         0x00100080U,
+         0x00110080U,
+         0x00120080U,
+         0x00130080U,
+         0x00140080U,
+         0x00150080U,
+         0x00160080U,
+         0x00170080U,
+         0x00180080U,
+         0x00190080U,
+         0x001A0080U,
+         0x001B0080U,
+         0x001C0080U,
+         0x001D0080U,
+         0x001E0080U,
+         0x001F0080U,
+         0x00200080U,
+         0x00210080U,
+         0x00220080U,
+         0x00230080U,
+         0x00240080U,
+         0x00250080U,
+         0x00260080U,
+         0x00270080U,
+         0x00280080U,
+         0x00290080U,
+         0x002A0080U,
+         0x002B0080U,
+         0x002C0080U,
+         0x002D0080U,
+         0x002E0080U,
+         0x002F0080U,
+         0x00300080U,
+         0x00310080U,
+         0x00320080U,
+         0x00330080U,
+         0x00340080U,
+         0x00350080U,
+         0x00360080U,
+         0x00370080U,
+         0x00380080U,
+         0x00390080U,
+         0x003A0080U,
+         0x003B0080U,
+         0x003C0080U,
+         0x003D0080U,
+         0x003E0080U,
+         0x003F0080U,
+         0x00400080U,
+         0x00410080U,
+         0x00420080U,
+         0x00430080U,
+         0x00440080U,
+         0x00450080U,
+         0x00460080U,
+         0x00470080U,
+         0x00480080U,
+         0x00490080U,
+         0x004A0080U,
+         0x004B0080U,
+         0x004C0080U,
+         0x004D0080U,
+         0x004E0080U,
+         0x004F0080U,
+         0x00500080U,
+         0x00510080U,
+         0x00520080U,
+         0x00530080U,
+         0x00540080U,
+         0x00550080U,
+         0x00560080U,
+         0x00570080U,
+         0x00580080U,
+         0x00590080U,
+         0x005A0080U,
+         0x005B0080U,
+         0x005C0080U,
+         0x005D0080U,
+         0x005E0080U,
+         0x005F0080U,
+         0x00600080U,
+         0x00610080U,
+         0x00620080U,
+         0x00630080U,
+         0x00640080U,
+         0x00650080U,
+         0x00660080U,
+         0x00670080U,
+         0x00680080U,
+         0x00690080U,
+         0x006A0080U,
+         0x006B0080U,
+         0x006C0080U,
+         0x006D0080U,
+         0x006E0080U,
+         0x006F0080U,
+         0x00700080U,
+         0x00710080U,
+         0x00720080U,
+         0x00730080U,
+         0x00740080U,
+         0x00750080U,
+         0x00760080U,
+         0x00770080U,
+         0x00780080U,
+         0x00790080U,
+         0x007A0080U,
+         0x007B0080U,
+         0x007C0080U,
+         0x007D0080U,
+         0x007E0080U,
+         0x007F0080U,
+         0x00800080U,
+         0x00810080U,
+         0x00820080U,
+         0x00830080U,
+         0x00840080U,
+         0x00850080U,
+         0x00860080U,
+         0x00870080U,
+         0x00880080U,
+         0x00890080U,
+         0x008A0080U,
+         0x008B0080U,
+         0x008C0080U,
+         0x008D0080U,
+         0x008E0080U,
+         0x008F0080U,
+         0x00900080U,
+         0x00910080U,
+         0x00920080U,
+         0x00930080U,
+         0x00940080U,
+         0x00950080U,
+         0x00960080U,
+         0x00970080U,
+         0x00980080U,
+         0x00990080U,
+         0x009A0080U,
+         0x009B0080U,
+         0x009C0080U,
+         0x009D0080U,
+         0x009E0080U,
+         0x009F0080U,
+         0x00A00080U,
+         0x00A10080U,
+         0x00A20080U,
+         0x00A30080U,
+         0x00A40080U,
+         0x00A50080U,
+         0x00A60080U,
+         0x00A70080U,
+         0x00A80080U,
+         0x00A90080U,
+         0x00AA0080U,
+         0x00AB0080U,
+         0x00AC0080U,
+         0x00AD0080U,
+         0x00AE0080U,
+         0x00AF0080U,
+         0x00B00080U,
+         0x00B10080U,
+         0x00B20080U,
+         0x00B30080U,
+         0x00B40080U,
+         0x00B50080U,
+         0x00B60080U,
+         0x00B70080U,
+         0x00B80080U,
+         0x00B90080U,
+         0x00BA0080U,
+         0x00BB0080U,
+         0x00BC0080U,
+         0x00BD0080U,
+         0x00BE0080U,
+         0x00BF0080U,
+         0x00C00080U,
+         0x00C10080U,
+         0x00C20080U,
+         0x00C30080U,
+         0x00C40080U,
+         0x00C50080U,
+         0x00C60080U,
+         0x00C70080U,
+         0x00C80080U,
+         0x00C90080U,
+         0x00CA0080U,
+         0x00CB0080U,
+         0x00CC0080U,
+         0x00CD0080U,
+         0x00CE0080U,
+         0x00CF0080U,
+         0x00D00080U,
+         0x00D10080U,
+         0x00D20080U,
+         0x00D30080U,
+         0x00D40080U,
+         0x00D50080U,
+         0x00D60080U,
+         0x00D70080U,
+         0x00D80080U,
+         0x00D90080U,
+         0x00DA0080U,
+         0x00DB0080U,
+         0x00DC0080U,
+         0x00DD0080U,
+         0x00DE0080U,
+         0x00DF0080U,
+         0x00E00080U,
+         0x00E10080U,
+         0x00E20080U,
+         0x00E30080U,
+         0x00E40080U,
+         0x00E50080U,
+         0x00E60080U,
+         0x00E70080U,
+         0x00E80080U,
+         0x00E90080U,
+         0x00EA0080U,
+         0x00EB0080U,
+         0x00EC0080U,
+         0x00ED0080U,
+         0x00EE0080U,
+         0x00EF0080U,
+         0x00F00080U,
+         0x00F10080U,
+         0x00F20080U,
+         0x00F30080U,
+         0x00F40080U,
+         0x00F50080U,
+         0x00F60080U,
+         0x00F70080U,
+         0x00F80080U,
+         0x00F90080U,
+         0x00FA0080U,
+         0x00FB0080U,
+         0x00FC0080U,
+         0x00FD0080U,
+         0x00FE0080U,
+         0x00FF0080U,
+         INFLATE_ENTRY_EXCEPTIONAL | INFLATE_ENTRY_END_OF_BLOCK,
+         0x00030000U,
+         0x00040000U,
+         0x00050000U,
+         0x00060000U,
+         0x00070000U,
+         0x00080000U,
+         0x00090000U,
+         0x000A0000U,
+         0x000B0100U,
+         0x000D0100U,
+         0x000F0100U,
+         0x00110100U,
+         0x00130200U,
+         0x00170200U,
+         0x001B0200U,
+         0x001F0200U,
+         0x00230300U,
+         0x002B0300U,
+         0x00330300U,
+         0x003B0300U,
+         0x00430400U,
+         0x00530400U,
+         0x00630400U,
+         0x00730400U,
+         0x00830500U,
+         0x00A30500U,
+         0x00C30500U,
+         0x00E30500U,
+         0x01020000U,
+         INFLATE_ENTRY_EXCEPTIONAL | INFLATE_ENTRY_INVALID_SYMBOL,
+         INFLATE_ENTRY_EXCEPTIONAL | INFLATE_ENTRY_INVALID_SYMBOL}};
+inline constexpr std::array<std::uint32_t, INFLATE_DISTANCE_SYMBOLS>
+    INFLATE_DISTANCE_RESULTS{
+        {0x00010000U,
+         0x00020000U,
+         0x00030000U,
+         0x00040000U,
+         0x00050100U,
+         0x00070100U,
+         0x00090200U,
+         0x000D0200U,
+         0x00110300U,
+         0x00190300U,
+         0x00210400U,
+         0x00310400U,
+         0x00410500U,
+         0x00610500U,
+         0x00810600U,
+         0x00C10600U,
+         0x01010700U,
+         0x01810700U,
+         0x02010800U,
+         0x03010800U,
+         0x04010900U,
+         0x06010900U,
+         0x08010A00U,
+         0x0C010A00U,
+         0x10010B00U,
+         0x18010B00U,
+         0x20010C00U,
+         0x30010C00U,
+         0x40010D00U,
+         0x60010D00U,
+         INFLATE_ENTRY_EXCEPTIONAL | INFLATE_ENTRY_INVALID_SYMBOL,
+         INFLATE_ENTRY_EXCEPTIONAL | INFLATE_ENTRY_INVALID_SYMBOL}};
+inline constexpr std::array<std::uint32_t, INFLATE_CODE_LENGTH_SYMBOLS>
+    INFLATE_CODE_LENGTH_RESULTS{
+        {0x00000000U, 0x00010000U, 0x00020000U, 0x00030000U, 0x00040000U,
+         0x00050000U, 0x00060000U, 0x00070000U, 0x00080000U, 0x00090000U,
+         0x000A0000U, 0x000B0000U, 0x000C0000U, 0x000D0000U, 0x000E0000U,
+         0x000F0000U, 0x00100000U, 0x00110000U, 0x00120000U}};
+
+inline auto inflate_reverse_bits(const std::uint32_t value,
+                                 const unsigned int length) -> std::uint32_t {
+  std::uint32_t result{0};
+  for (unsigned int index = 0; index < length; ++index) {
+    result |= ((value >> index) & 1U) << (length - 1 - index);
+  }
+
+  return result;
+}
+
+// The symbol results hold the number of extra bits in bits 8 to 12, which the
+// table entry replaces with the codeword length, adding both to the bits to
+// consume so that decoding takes the codeword and its extra bits in one shift
+inline auto inflate_make_entry(const std::uint32_t result,
+                               const unsigned int length) -> std::uint32_t {
+  const std::uint32_t extra{(result >> 8) & 0x1fU};
+  return (result & ~std::uint32_t{0x1f00U}) | (length << 8) | (length + extra);
+}
+
+// Builds a decode table from a sequence of code lengths as per RFC 1951
+// section 3.2.2, returning a null pointer on success or the reason the code
+// is invalid. Codewords are read starting from their most significant bit
+// while the input is packed starting from the least significant bit, so every
+// index is the bit reversal of the codeword
+inline auto inflate_build_table(const std::uint8_t *lengths,
+                                const std::size_t symbol_count,
+                                const std::uint32_t *results,
+                                const unsigned int table_bits,
+                                std::uint32_t *table) -> const char * {
+  std::array<std::uint16_t, INFLATE_MAXIMUM_CODEWORD_LENGTH + 1> counts{};
+  for (std::size_t symbol = 0; symbol < symbol_count; ++symbol) {
+    counts[lengths[symbol]] += 1;
+  }
+
+  const std::size_t used_symbols{symbol_count - counts[0]};
+  int remaining_codespace{1};
+  for (unsigned int length = 1; length <= INFLATE_MAXIMUM_CODEWORD_LENGTH;
+       ++length) {
+    remaining_codespace <<= 1;
+    remaining_codespace -= counts[length];
+    if (remaining_codespace < 0) {
+      return "Over-subscribed Huffman code";
+    }
+  }
+
+  const std::size_t primary_size{std::size_t{1} << table_bits};
+  if (remaining_codespace > 0) {
+    // RFC 1951 section 3.2.7 only sanctions an incomplete code that is empty
+    // or that holds a single codeword of one bit
+    if (used_symbols > 1 || (used_symbols == 1 && counts[1] != 1)) {
+      return "Incomplete Huffman code";
+    }
+
+    const std::uint32_t invalid{INFLATE_ENTRY_EXCEPTIONAL |
+                                INFLATE_ENTRY_INVALID_CODE |
+                                INFLATE_MAXIMUM_CODEWORD_LENGTH};
+    for (std::size_t index = 0; index < primary_size; ++index) {
+      table[index] = invalid;
+    }
+  }
+
+  std::array<std::uint16_t, INFLATE_MAXIMUM_CODEWORD_LENGTH + 2> offsets{};
+  for (unsigned int length = 1; length <= INFLATE_MAXIMUM_CODEWORD_LENGTH;
+       ++length) {
+    offsets[length + 1] =
+        static_cast<std::uint16_t>(offsets[length] + counts[length]);
+  }
+
+  std::array<std::uint16_t, INFLATE_LITERAL_LENGTH_SYMBOLS> sorted{};
+  for (std::size_t symbol = 0; symbol < symbol_count; ++symbol) {
+    if (lengths[symbol] != 0) {
+      sorted[offsets[lengths[symbol]]] = static_cast<std::uint16_t>(symbol);
+      offsets[lengths[symbol]] += 1;
+    }
+  }
+
+  // An allowed incomplete code holds at most one codeword, of one bit, whose
+  // reversal is zero
+  if (remaining_codespace > 0) {
+    if (used_symbols == 1) {
+      const std::uint32_t entry{inflate_make_entry(results[sorted[0]], 1)};
+      for (std::size_t slot = 0; slot < primary_size; slot += 2) {
+        table[slot] = entry;
+      }
+    }
+
+    return nullptr;
+  }
+
+  // Walks the codewords in canonical order while keeping them bit reversed,
+  // where incrementing a reversed codeword flips its highest zero bit and
+  // clears every bit above it. The primary table starts as wide as the
+  // shortest codeword and doubles in size with every length, so that every
+  // shorter codeword is replicated with a single copy
+  unsigned int length{1};
+  while (counts[length] == 0) {
+    length += 1;
+  }
+
+  std::uint32_t codeword{0};
+  std::size_t position{0};
+  std::size_t table_end{std::size_t{1} << length};
+  unsigned int count{counts[length]};
+  while (length <= table_bits) {
+    while (count > 0) {
+      table[codeword] = inflate_make_entry(results[sorted[position]], length);
+      position += 1;
+      count -= 1;
+      if (codeword == table_end - 1) {
+        while (table_end < primary_size) {
+          std::memcpy(table + table_end, table,
+                      table_end * sizeof(std::uint32_t));
+          table_end <<= 1;
+        }
+
+        return nullptr;
+      }
+
+      const auto flipped{codeword ^ static_cast<std::uint32_t>(table_end - 1)};
+      const std::uint32_t bit{std::uint32_t{1}
+                              << (31 - std::countl_zero(flipped))};
+      codeword = (codeword & (bit - 1)) | bit;
+    }
+
+    while (count == 0) {
+      length += 1;
+      if (length <= table_bits) {
+        std::memcpy(table + table_end, table,
+                    table_end * sizeof(std::uint32_t));
+        table_end <<= 1;
+      }
+
+      count = counts[length];
+    }
+  }
+
+  // Longer codewords sharing the same first bits share a subtable, and
+  // canonical codewords sharing those bits are contiguous
+  const unsigned int subtable_bits{INFLATE_MAXIMUM_CODEWORD_LENGTH -
+                                   table_bits};
+  const std::size_t subtable_size{std::size_t{1} << subtable_bits};
+  std::size_t next_subtable{primary_size};
+  std::uint32_t current_prefix{0xffffffffU};
+  std::size_t current_subtable{0};
+  while (true) {
+    const std::uint32_t prefix{codeword &
+                               static_cast<std::uint32_t>(primary_size - 1)};
+    if (prefix != current_prefix) {
+      current_prefix = prefix;
+      current_subtable = next_subtable;
+      next_subtable += subtable_size;
+      table[prefix] = INFLATE_ENTRY_EXCEPTIONAL | INFLATE_ENTRY_SUBTABLE |
+                      (static_cast<std::uint32_t>(current_subtable) << 16) |
+                      table_bits;
+    }
+
+    const unsigned int remaining_length{length - table_bits};
+    const std::uint32_t entry{
+        inflate_make_entry(results[sorted[position]], remaining_length)};
+    position += 1;
+    for (std::size_t slot = codeword >> table_bits; slot < subtable_size;
+         slot += std::size_t{1} << remaining_length) {
+      table[current_subtable + slot] = entry;
+    }
+
+    const std::uint32_t last{(std::uint32_t{1} << length) - 1};
+    if (codeword == last) {
+      return nullptr;
+    }
+
+    const auto flipped{codeword ^ last};
+    const std::uint32_t bit{std::uint32_t{1}
+                            << (31 - std::countl_zero(flipped))};
+    codeword = (codeword & (bit - 1)) | bit;
+    count -= 1;
+    while (count == 0) {
+      length += 1;
+      count = counts[length];
+    }
+  }
+}
+
+enum class InflateStatus : std::uint8_t { Done, NeedInput, OutputFull };
+
+// The output buffer holds the bytes that back-references may point to before
+// the next output position, and the input buffer holds the compressed bytes
+// not yet read. Final input means no more compressed bytes will ever follow
+struct InflateBuffers {
+  const std::uint8_t *input_next;
+  const std::uint8_t *input_end;
+  bool input_final;
+  std::uint8_t *output_begin;
+  std::uint8_t *output_next;
+  std::uint8_t *output_end;
+};
+
+// Decodes a sequence of gzip members (RFC 1952) holding deflate data
+// (RFC 1951). Every call makes as much progress as the buffers allow and
+// returns when the input is exhausted, the output is full, or the data ended
+class InflateDecoder {
+public:
+  // A dynamic block header never exceeds this many bytes, so holding at least
+  // this much unread input before a block header avoids suspending inside it
+  static constexpr std::size_t INPUT_MARGIN{1024};
+
+  auto decode(InflateBuffers &buffers) -> InflateStatus {
+    this->checksum_position_ = buffers.output_next;
+    this->history_start_ =
+        buffers.output_next -
+        std::min(this->member_history_,
+                 static_cast<std::size_t>(buffers.output_next -
+                                          buffers.output_begin));
+
+    while (true) {
+      switch (this->state_) {
+        case State::MemberStart:
+          if (!this->start_member(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::HeaderFixed:
+          if (!this->read_header_fixed(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::HeaderExtraLength:
+          if (!this->read_header_extra_length(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::HeaderExtra:
+          if (!this->skip_header_extra(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::HeaderName:
+        case State::HeaderComment:
+          if (!this->skip_header_string(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::HeaderChecksum:
+          if (!this->read_header_checksum(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::BlockHeader:
+          if (!this->read_block_header(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::StoredLength:
+          if (!this->read_stored_length(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::StoredData: {
+          const auto progress{this->copy_stored_data(buffers)};
+          if (progress != InflateStatus::Done) {
+            return this->leave(buffers, progress);
+          }
+
+          break;
+        }
+        case State::Huffman: {
+          const auto progress{this->decode_huffman(buffers)};
+          if (progress != InflateStatus::Done) {
+            return this->leave(buffers, progress);
+          }
+
+          break;
+        }
+        case State::Trailer:
+          if (!this->read_trailer(buffers)) {
+            return this->leave(buffers, InflateStatus::NeedInput);
+          }
+
+          break;
+        case State::Done:
+          return this->leave(buffers, InflateStatus::Done);
+      }
+    }
+  }
+
+  // Whole bytes already moved from the input into the bit buffer but not yet
+  // consumed. A caller that compacts its input buffer must keep them in place
+  // before the next input position
+  [[nodiscard]] auto buffered_input() const -> std::size_t {
+    return this->bits_available_ / 8;
+  }
+
+private:
+  enum class State : std::uint8_t {
+    MemberStart,
+    HeaderFixed,
+    HeaderExtraLength,
+    HeaderExtra,
+    HeaderName,
+    HeaderComment,
+    HeaderChecksum,
+    BlockHeader,
+    StoredLength,
+    StoredData,
+    Huffman,
+    Trailer,
+    Done
+  };
+
+  static constexpr std::uint8_t FLAG_HEADER_CHECKSUM{0x02};
+  static constexpr std::uint8_t FLAG_EXTRA{0x04};
+  static constexpr std::uint8_t FLAG_NAME{0x08};
+  static constexpr std::uint8_t FLAG_COMMENT{0x10};
+  static constexpr std::uint8_t FLAG_RESERVED{0xe0};
+
+  // Enough input for two word refills between the checks, and enough output
+  // for the longest match plus the bytes that chunked copies write past it
+  static constexpr std::size_t FAST_INPUT_MARGIN{32};
+  static constexpr std::size_t FAST_OUTPUT_MARGIN{258 + 32};
+
+  // The smallest multiple of every distance below eight that is at least
+  // eight, so overlapping matches can continue with whole word copies
+  static constexpr std::array<std::size_t, 8> SHORT_DISTANCE_STEP{
+      {0, 8, 8, 9, 8, 10, 12, 14}};
+
+  static auto load_word(const std::uint8_t *data) -> std::uint64_t {
+    std::uint64_t word{0};
+    std::memcpy(&word, data, sizeof(word));
+    if (std::endian::native == std::endian::big) {
+      word = std::byteswap(word);
+    }
+
+    return word;
+  }
+
+  static auto low_bits(const std::uint64_t value, const unsigned int count)
+      -> std::uint32_t {
+    return static_cast<std::uint32_t>(value &
+                                      ((std::uint64_t{1} << count) - 1));
+  }
+
+  static auto available_input(const InflateBuffers &buffers) -> std::size_t {
+    return static_cast<std::size_t>(buffers.input_end - buffers.input_next);
+  }
+
+  static auto available_output(const InflateBuffers &buffers) -> std::size_t {
+    return static_cast<std::size_t>(buffers.output_end - buffers.output_next);
+  }
+
+  auto leave(InflateBuffers &buffers, const InflateStatus status)
+      -> InflateStatus {
+    this->flush_member_progress(buffers);
+    return status;
+  }
+
+  auto flush_member_progress(const InflateBuffers &buffers) -> void {
+    const auto produced{static_cast<std::size_t>(buffers.output_next -
+                                                 this->checksum_position_)};
+    if (produced > 0) {
+      this->member_checksum_ =
+          crc32_update(this->member_checksum_,
+                       std::string_view{reinterpret_cast<const char *>(
+                                            this->checksum_position_),
+                                        produced});
+      this->member_size_ += static_cast<std::uint32_t>(produced);
+      this->member_history_ += produced;
+      this->checksum_position_ = buffers.output_next;
+    }
+  }
+
+  auto update_header_checksum(const std::uint8_t *data, const std::size_t size)
+      -> void {
+    if ((this->flags_ & FLAG_HEADER_CHECKSUM) != 0) {
+      this->header_checksum_ = crc32_update(
+          this->header_checksum_,
+          std::string_view{reinterpret_cast<const char *>(data), size});
+    }
+  }
+
+  [[noreturn]] static auto unexpected_end() -> void {
+    throw GZIPError{"Unexpected end of source stream"};
+  }
+
+  [[nodiscard]] auto real_bits() const -> long long {
+    return static_cast<long long>(this->bits_available_) -
+           (static_cast<long long>(this->overread_) * 8);
+  }
+
+  // Reports the input as truncated when the bits that led to the error were
+  // not all real input, as the error may only be an artifact of the padding
+  [[noreturn]] auto fail(const char *message, const long long bits_needed) const
+      -> void {
+    if (this->real_bits() < bits_needed) {
+      unexpected_end();
+    }
+
+    throw GZIPError{message};
+  }
+
+  auto check_not_overread() const -> void {
+    if (this->real_bits() < 0) {
+      unexpected_end();
+    }
+  }
+
+  auto consume(const unsigned int count) -> void {
+    this->bit_buffer_ >>= count;
+    this->bits_available_ -= count;
+  }
+
+  // Past the end of the final input the bit buffer is padded with zero bytes,
+  // which are only an error if they end up consumed. Stopping short of 56
+  // bits keeps at most 63 bits buffered, which the word refill relies on
+  auto refill_careful(InflateBuffers &buffers) -> void {
+    while (this->bits_available_ < 56) {
+      if (buffers.input_next < buffers.input_end) {
+        this->bit_buffer_ |= static_cast<std::uint64_t>(*buffers.input_next)
+                             << this->bits_available_;
+        buffers.input_next += 1;
+      } else if (buffers.input_final) {
+        this->overread_ += 1;
+      } else {
+        return;
+      }
+
+      this->bits_available_ += 8;
+    }
+  }
+
+  auto read_bits(InflateBuffers &buffers, const unsigned int count)
+      -> std::uint32_t {
+    if (this->bits_available_ < count) {
+      this->refill_careful(buffers);
+    }
+
+    const auto value{low_bits(this->bit_buffer_, count)};
+    this->consume(count);
+    return value;
+  }
+
+  // Discards the bits up to the next byte boundary and hands the whole bytes
+  // still in the bit buffer back to the input
+  auto align_to_byte(InflateBuffers &buffers) -> void {
+    const auto whole_bytes{this->bits_available_ / 8};
+    if (whole_bytes < this->overread_) {
+      unexpected_end();
+    }
+
+    buffers.input_next -= whole_bytes - this->overread_;
+    this->bit_buffer_ = 0;
+    this->bits_available_ = 0;
+    this->overread_ = 0;
+  }
+
+  [[nodiscard]] auto header_state_after(const State completed) const -> State {
+    if (completed == State::HeaderFixed && (this->flags_ & FLAG_EXTRA) != 0) {
+      return State::HeaderExtraLength;
+    }
+
+    if ((completed == State::HeaderFixed || completed == State::HeaderExtra) &&
+        (this->flags_ & FLAG_NAME) != 0) {
+      return State::HeaderName;
+    }
+
+    if (completed != State::HeaderComment &&
+        (this->flags_ & FLAG_COMMENT) != 0) {
+      return State::HeaderComment;
+    }
+
+    if ((this->flags_ & FLAG_HEADER_CHECKSUM) != 0) {
+      return State::HeaderChecksum;
+    }
+
+    return State::BlockHeader;
+  }
+
+  auto start_member(InflateBuffers &buffers) -> bool {
+    const auto available{available_input(buffers)};
+    if (this->first_member_) {
+      if (available == 0) {
+        if (buffers.input_final) {
+          throw GZIPError{"Empty source stream"};
+        }
+
+        return false;
+      }
+
+      if (buffers.input_next[0] != 0x1f) {
+        throw GZIPError{"Invalid gzip magic bytes"};
+      }
+
+      if (available < 2) {
+        if (buffers.input_final) {
+          unexpected_end();
+        }
+
+        return false;
+      }
+
+      if (buffers.input_next[1] != 0x8b) {
+        throw GZIPError{"Invalid gzip magic bytes"};
+      }
+    } else {
+      // Like gzip(1), data after a member that does not start with the
+      // identification bytes is ignored as trailing garbage
+      if (available < 2) {
+        if (buffers.input_final) {
+          this->state_ = State::Done;
+          return true;
+        }
+
+        return false;
+      }
+
+      if (buffers.input_next[0] != 0x1f || buffers.input_next[1] != 0x8b) {
+        this->state_ = State::Done;
+        return true;
+      }
+    }
+
+    this->first_member_ = false;
+    this->flags_ = FLAG_HEADER_CHECKSUM;
+    this->header_checksum_ = 0;
+    this->update_header_checksum(buffers.input_next, 2);
+    buffers.input_next += 2;
+    this->member_checksum_ = 0;
+    this->member_size_ = 0;
+    this->member_history_ = 0;
+    this->checksum_position_ = buffers.output_next;
+    this->history_start_ = buffers.output_next;
+    this->state_ = State::HeaderFixed;
+    return true;
+  }
+
+  auto read_header_fixed(InflateBuffers &buffers) -> bool {
+    const auto available{available_input(buffers)};
+    if (available >= 1 && buffers.input_next[0] != 8) {
+      throw GZIPError{"Unsupported gzip compression method"};
+    }
+
+    if (available >= 2 && (buffers.input_next[1] & FLAG_RESERVED) != 0) {
+      throw GZIPError{"Reserved gzip FLG bits must be zero"};
+    }
+
+    // The compression method, flags, modification time, extra flags, and
+    // operating system
+    if (available < 8) {
+      if (buffers.input_final) {
+        unexpected_end();
+      }
+
+      return false;
+    }
+
+    const std::uint8_t checksum_flag{FLAG_HEADER_CHECKSUM};
+    const bool track{(buffers.input_next[1] & checksum_flag) != 0};
+    this->flags_ = track ? checksum_flag : std::uint8_t{0};
+    this->update_header_checksum(buffers.input_next, 8);
+    if (!track) {
+      this->header_checksum_ = 0;
+    }
+
+    this->flags_ = buffers.input_next[1];
+    buffers.input_next += 8;
+    this->state_ = this->header_state_after(State::HeaderFixed);
+    return true;
+  }
+
+  auto read_header_extra_length(InflateBuffers &buffers) -> bool {
+    if (available_input(buffers) < 2) {
+      if (buffers.input_final) {
+        unexpected_end();
+      }
+
+      return false;
+    }
+
+    this->skip_remaining_ =
+        static_cast<std::size_t>(buffers.input_next[0]) |
+        (static_cast<std::size_t>(buffers.input_next[1]) << 8);
+    this->update_header_checksum(buffers.input_next, 2);
+    buffers.input_next += 2;
+    this->state_ = State::HeaderExtra;
+    return true;
+  }
+
+  auto skip_header_extra(InflateBuffers &buffers) -> bool {
+    const auto amount{
+        std::min(this->skip_remaining_, available_input(buffers))};
+    this->update_header_checksum(buffers.input_next, amount);
+    buffers.input_next += amount;
+    this->skip_remaining_ -= amount;
+    if (this->skip_remaining_ > 0) {
+      if (buffers.input_final) {
+        unexpected_end();
+      }
+
+      return false;
+    }
+
+    this->state_ = this->header_state_after(State::HeaderExtra);
+    return true;
+  }
+
+  // The file name and the comment are zero-terminated
+  auto skip_header_string(InflateBuffers &buffers) -> bool {
+    const auto available{available_input(buffers)};
+    const auto *terminator{static_cast<const std::uint8_t *>(
+        std::memchr(buffers.input_next, 0, available))};
+    if (terminator == nullptr) {
+      this->update_header_checksum(buffers.input_next, available);
+      buffers.input_next += available;
+      if (buffers.input_final) {
+        unexpected_end();
+      }
+
+      return false;
+    }
+
+    const auto amount{
+        static_cast<std::size_t>(terminator - buffers.input_next) + 1};
+    this->update_header_checksum(buffers.input_next, amount);
+    buffers.input_next += amount;
+    this->state_ = this->header_state_after(this->state_);
+    return true;
+  }
+
+  auto read_header_checksum(InflateBuffers &buffers) -> bool {
+    if (available_input(buffers) < 2) {
+      if (buffers.input_final) {
+        unexpected_end();
+      }
+
+      return false;
+    }
+
+    // RFC 1952 section 2.3.1: the two least significant bytes of the CRC-32
+    // of every header byte before this field
+    const auto stored{static_cast<std::uint32_t>(buffers.input_next[0]) |
+                      (static_cast<std::uint32_t>(buffers.input_next[1]) << 8)};
+    if (stored != (this->header_checksum_ & 0xffffU)) {
+      throw GZIPError{"FHCRC mismatch"};
+    }
+
+    buffers.input_next += 2;
+    this->state_ = State::BlockHeader;
+    return true;
+  }
+
+  auto end_block(InflateBuffers &buffers) -> void {
+    // Checksumming the output of every block as soon as it ends reads it
+    // while it is still in cache
+    this->flush_member_progress(buffers);
+    if (this->final_block_) {
+      this->align_to_byte(buffers);
+      this->final_block_ = false;
+      this->state_ = State::Trailer;
+    } else {
+      this->state_ = State::BlockHeader;
+    }
+  }
+
+  auto read_block_header(InflateBuffers &buffers) -> bool {
+    if (!buffers.input_final && available_input(buffers) < INPUT_MARGIN) {
+      return false;
+    }
+
+    this->final_block_ = this->read_bits(buffers, 1) != 0;
+    const auto type{this->read_bits(buffers, 2)};
+    this->check_not_overread();
+    switch (type) {
+      case 0:
+        this->align_to_byte(buffers);
+        this->state_ = State::StoredLength;
+        return true;
+      case 1:
+        this->load_fixed_tables();
+        this->state_ = State::Huffman;
+        return true;
+      case 2:
+        this->read_dynamic_header(buffers);
+        this->state_ = State::Huffman;
+        return true;
+      default:
+        throw GZIPError{"Reserved deflate block type"};
+    }
+  }
+
+  auto read_stored_length(InflateBuffers &buffers) -> bool {
+    if (available_input(buffers) < 4) {
+      if (buffers.input_final) {
+        unexpected_end();
+      }
+
+      return false;
+    }
+
+    const auto length{static_cast<std::uint32_t>(buffers.input_next[0]) |
+                      (static_cast<std::uint32_t>(buffers.input_next[1]) << 8)};
+    const auto complement{
+        static_cast<std::uint32_t>(buffers.input_next[2]) |
+        (static_cast<std::uint32_t>(buffers.input_next[3]) << 8)};
+    if (length != (~complement & 0xffffU)) {
+      throw GZIPError{"Stored block LEN/NLEN mismatch"};
+    }
+
+    buffers.input_next += 4;
+    this->stored_remaining_ = length;
+    this->state_ = State::StoredData;
+    return true;
+  }
+
+  auto copy_stored_data(InflateBuffers &buffers) -> InflateStatus {
+    while (this->stored_remaining_ > 0) {
+      if (available_output(buffers) == 0) {
+        return InflateStatus::OutputFull;
+      }
+
+      const auto input{available_input(buffers)};
+      if (input == 0) {
+        if (buffers.input_final) {
+          unexpected_end();
+        }
+
+        return InflateStatus::NeedInput;
+      }
+
+      const auto amount{std::min(
+          {this->stored_remaining_, input, available_output(buffers)})};
+      std::memcpy(buffers.output_next, buffers.input_next, amount);
+      buffers.input_next += amount;
+      buffers.output_next += amount;
+      this->stored_remaining_ -= amount;
+    }
+
+    this->end_block(buffers);
+    return InflateStatus::Done;
+  }
+
+  auto read_trailer(InflateBuffers &buffers) -> bool {
+    if (available_input(buffers) < 8) {
+      if (buffers.input_final) {
+        unexpected_end();
+      }
+
+      return false;
+    }
+
+    this->flush_member_progress(buffers);
+    const auto *data{buffers.input_next};
+    const auto checksum{static_cast<std::uint32_t>(data[0]) |
+                        (static_cast<std::uint32_t>(data[1]) << 8) |
+                        (static_cast<std::uint32_t>(data[2]) << 16) |
+                        (static_cast<std::uint32_t>(data[3]) << 24)};
+    const auto size{static_cast<std::uint32_t>(data[4]) |
+                    (static_cast<std::uint32_t>(data[5]) << 8) |
+                    (static_cast<std::uint32_t>(data[6]) << 16) |
+                    (static_cast<std::uint32_t>(data[7]) << 24)};
+    if (checksum != this->member_checksum_) {
+      throw GZIPError{"Gzip member CRC32 mismatch"};
+    }
+
+    if (size != this->member_size_) {
+      throw GZIPError{"Gzip member ISIZE mismatch"};
+    }
+
+    buffers.input_next += 8;
+    this->state_ = State::MemberStart;
+    return true;
+  }
+
+  auto load_fixed_tables() -> void {
+    if (this->fixed_tables_) {
+      return;
+    }
+
+    // RFC 1951 section 3.2.6
+    std::array<std::uint8_t, INFLATE_LITERAL_LENGTH_SYMBOLS> literal_lengths{};
+    std::memset(literal_lengths.data(), 8, 144);
+    std::memset(literal_lengths.data() + 144, 9, 112);
+    std::memset(literal_lengths.data() + 256, 7, 24);
+    std::memset(literal_lengths.data() + 280, 8, 8);
+    inflate_build_table(literal_lengths.data(), literal_lengths.size(),
+                        INFLATE_LITERAL_LENGTH_RESULTS.data(),
+                        INFLATE_LITERAL_LENGTH_TABLE_BITS,
+                        this->literal_length_table_.data());
+    std::array<std::uint8_t, INFLATE_DISTANCE_SYMBOLS> distance_lengths{};
+    std::memset(distance_lengths.data(), 5, distance_lengths.size());
+    inflate_build_table(distance_lengths.data(), distance_lengths.size(),
+                        INFLATE_DISTANCE_RESULTS.data(),
+                        INFLATE_DISTANCE_TABLE_BITS,
+                        this->distance_table_.data());
+    this->fixed_tables_ = true;
+  }
+
+  auto read_dynamic_header(InflateBuffers &buffers) -> void {
+    const auto literal_length_count{this->read_bits(buffers, 5) + 257};
+    const auto distance_count{this->read_bits(buffers, 5) + 1};
+    const auto code_length_count{this->read_bits(buffers, 4) + 4};
+    if (literal_length_count > 286) {
+      this->fail("Too many literal/length codes", 0);
+    }
+
+    std::array<std::uint8_t, INFLATE_CODE_LENGTH_SYMBOLS> code_length_lengths{};
+    for (std::size_t index = 0; index < code_length_count; ++index) {
+      code_length_lengths[INFLATE_CODE_LENGTH_ORDER[index]] =
+          static_cast<std::uint8_t>(this->read_bits(buffers, 3));
+    }
+
+    const auto *code_length_error{inflate_build_table(
+        code_length_lengths.data(), code_length_lengths.size(),
+        INFLATE_CODE_LENGTH_RESULTS.data(), INFLATE_CODE_LENGTH_TABLE_BITS,
+        this->code_length_table_.data())};
+    if (code_length_error != nullptr) {
+      this->fail(code_length_error, 0);
+    }
+
+    std::array<std::uint8_t,
+               INFLATE_LITERAL_LENGTH_SYMBOLS + INFLATE_DISTANCE_SYMBOLS>
+        lengths{};
+    const std::size_t total{literal_length_count + distance_count};
+    std::size_t index{0};
+    while (index < total) {
+      if (this->bits_available_ < 14) {
+        this->refill_careful(buffers);
+      }
+
+      const auto entry{this->code_length_table_[low_bits(
+          this->bit_buffer_, INFLATE_CODE_LENGTH_TABLE_BITS)]};
+      if ((entry & INFLATE_ENTRY_EXCEPTIONAL) != 0) {
+        this->fail("Invalid Huffman code", INFLATE_CODE_LENGTH_TABLE_BITS);
+      }
+
+      this->consume(entry & 0x1fU);
+      const auto symbol{entry >> 16};
+      if (symbol < 16) {
+        lengths[index] = static_cast<std::uint8_t>(symbol);
+        index += 1;
+        continue;
+      }
+
+      std::size_t repeats{0};
+      std::uint8_t value{0};
+      if (symbol == 16) {
+        if (index == 0) {
+          this->fail("Repeat-previous code length with no previous", 0);
+        }
+
+        value = lengths[index - 1];
+        repeats = this->read_bits(buffers, 2) + 3;
+      } else if (symbol == 17) {
+        repeats = this->read_bits(buffers, 3) + 3;
+      } else {
+        repeats = this->read_bits(buffers, 7) + 11;
+      }
+
+      if (index + repeats > total) {
+        this->fail("Code length count overflow", 0);
+      }
+
+      std::memset(lengths.data() + index, value, repeats);
+      index += repeats;
+    }
+
+    this->check_not_overread();
+    const auto *literal_length_error{inflate_build_table(
+        lengths.data(), literal_length_count,
+        INFLATE_LITERAL_LENGTH_RESULTS.data(),
+        INFLATE_LITERAL_LENGTH_TABLE_BITS, this->literal_length_table_.data())};
+    if (literal_length_error != nullptr) {
+      throw GZIPError{literal_length_error};
+    }
+
+    const auto *distance_error{inflate_build_table(
+        lengths.data() + literal_length_count, distance_count,
+        INFLATE_DISTANCE_RESULTS.data(), INFLATE_DISTANCE_TABLE_BITS,
+        this->distance_table_.data())};
+    if (distance_error != nullptr) {
+      throw GZIPError{distance_error};
+    }
+
+    this->fixed_tables_ = false;
+  }
+
+  // Copies the match byte by byte, which is always correct for overlapping
+  // ranges, stopping when the output fills up
+  auto copy_match_careful(InflateBuffers &buffers) -> InflateStatus {
+    const auto amount{
+        std::min(this->pending_length_, available_output(buffers))};
+    const std::uint8_t *source{buffers.output_next - this->pending_distance_};
+    for (std::size_t index = 0; index < amount; ++index) {
+      buffers.output_next[index] = source[index];
+    }
+
+    buffers.output_next += amount;
+    this->pending_length_ -= amount;
+    return this->pending_length_ > 0 ? InflateStatus::OutputFull
+                                     : InflateStatus::Done;
+  }
+
+  auto decode_huffman(InflateBuffers &buffers) -> InflateStatus {
+    if (this->pending_length_ > 0 &&
+        this->copy_match_careful(buffers) != InflateStatus::Done) {
+      return InflateStatus::OutputFull;
+    }
+
+    if (this->decode_huffman_fast(buffers)) {
+      return InflateStatus::Done;
+    }
+
+    return this->decode_huffman_careful(buffers);
+  }
+
+  // Returns whether the block ended
+  auto decode_huffman_fast(InflateBuffers &buffers) -> bool {
+    const auto *literal_length_table{this->literal_length_table_.data()};
+    const auto *distance_table{this->distance_table_.data()};
+    const auto *input_next{buffers.input_next};
+    const auto *const input_limit{available_input(buffers) >= FAST_INPUT_MARGIN
+                                      ? buffers.input_end - FAST_INPUT_MARGIN
+                                      : buffers.input_next};
+    auto *output_next{buffers.output_next};
+    auto *const output_limit{available_output(buffers) >= FAST_OUTPUT_MARGIN
+                                 ? buffers.output_end - FAST_OUTPUT_MARGIN
+                                 : buffers.output_next};
+    const auto *const history_start{this->history_start_};
+    auto bit_buffer{this->bit_buffer_};
+    auto bits_available{this->bits_available_};
+    // Only the lowest six bits of the bit count are meaningful, which lets
+    // literals subtract their whole table entry instead of masking it first
+    bool block_ended{false};
+
+    // Every iteration starts with at least 56 buffered bits, enough for
+    // three literals from the primary table or for a whole match
+    if (input_next < input_limit && output_next < output_limit) {
+      bit_buffer |= load_word(input_next) << (bits_available & 63U);
+      input_next += (63U - (bits_available & 63U)) >> 3;
+      bits_available |= 56;
+      auto entry{literal_length_table[low_bits(
+          bit_buffer, INFLATE_LITERAL_LENGTH_TABLE_BITS)]};
+      while (true) {
+        if ((entry & INFLATE_ENTRY_LITERAL) != 0) {
+          // Every literal leaves the entry of the next symbol loaded, and a
+          // refill only appends bits past the ones that entry was read from
+          bit_buffer >>= entry & 0x3fU;
+          bits_available -= entry;
+          *output_next++ = static_cast<std::uint8_t>(entry >> 16);
+          entry = literal_length_table[low_bits(
+              bit_buffer, INFLATE_LITERAL_LENGTH_TABLE_BITS)];
+          if ((entry & INFLATE_ENTRY_LITERAL) != 0) {
+            bit_buffer >>= entry & 0x3fU;
+            bits_available -= entry;
+            *output_next++ = static_cast<std::uint8_t>(entry >> 16);
+            entry = literal_length_table[low_bits(
+                bit_buffer, INFLATE_LITERAL_LENGTH_TABLE_BITS)];
+            if ((entry & INFLATE_ENTRY_LITERAL) != 0) {
+              bit_buffer >>= entry & 0x3fU;
+              bits_available -= entry;
+              *output_next++ = static_cast<std::uint8_t>(entry >> 16);
+              entry = literal_length_table[low_bits(
+                  bit_buffer, INFLATE_LITERAL_LENGTH_TABLE_BITS)];
+            }
+          }
+
+          if (input_next >= input_limit || output_next >= output_limit) {
+            break;
+          }
+
+          bit_buffer |= load_word(input_next) << (bits_available & 63U);
+          input_next += (63U - (bits_available & 63U)) >> 3;
+          bits_available |= 56;
+          continue;
+        }
+
+        if ((entry & INFLATE_ENTRY_SUBTABLE) != 0) {
+          bit_buffer >>= INFLATE_LITERAL_LENGTH_TABLE_BITS;
+          bits_available -= INFLATE_LITERAL_LENGTH_TABLE_BITS;
+          entry = literal_length_table
+              [(entry >> 16) +
+               low_bits(bit_buffer, INFLATE_MAXIMUM_CODEWORD_LENGTH -
+                                        INFLATE_LITERAL_LENGTH_TABLE_BITS)];
+        }
+
+        if ((entry & INFLATE_ENTRY_LITERAL) != 0) {
+          bit_buffer >>= entry & 0x3fU;
+          bits_available -= entry;
+          *output_next++ = static_cast<std::uint8_t>(entry >> 16);
+        } else if ((entry & INFLATE_ENTRY_EXCEPTIONAL) != 0) {
+          if ((entry & INFLATE_ENTRY_END_OF_BLOCK) != 0) {
+            bit_buffer >>= entry & 0x1fU;
+            bits_available -= entry & 0x1fU;
+            block_ended = true;
+            break;
+          }
+
+          if ((entry & INFLATE_ENTRY_INVALID_CODE) != 0) {
+            throw GZIPError{"Invalid Huffman code"};
+          }
+
+          throw GZIPError{"Invalid literal/length code"};
+        } else {
+          const auto buffer_before_length{bit_buffer};
+          bit_buffer >>= entry & 0x3fU;
+          bits_available -= entry;
+          const std::size_t length{
+              (entry >> 16) + (low_bits(buffer_before_length, entry & 0x1fU) >>
+                               ((entry >> 8) & 0x1fU))};
+
+          auto distance_entry{distance_table[low_bits(
+              bit_buffer, INFLATE_DISTANCE_TABLE_BITS)]};
+          if ((distance_entry & INFLATE_ENTRY_EXCEPTIONAL) != 0) {
+            if ((distance_entry & INFLATE_ENTRY_SUBTABLE) != 0) {
+              bit_buffer >>= INFLATE_DISTANCE_TABLE_BITS;
+              bits_available -= INFLATE_DISTANCE_TABLE_BITS;
+              distance_entry =
+                  distance_table[(distance_entry >> 16) +
+                                 low_bits(bit_buffer,
+                                          INFLATE_MAXIMUM_CODEWORD_LENGTH -
+                                              INFLATE_DISTANCE_TABLE_BITS)];
+            }
+
+            if ((distance_entry & INFLATE_ENTRY_INVALID_CODE) != 0) {
+              throw GZIPError{"Invalid Huffman code"};
+            }
+
+            if ((distance_entry & INFLATE_ENTRY_INVALID_SYMBOL) != 0) {
+              throw GZIPError{"Invalid distance code"};
+            }
+          }
+
+          const auto buffer_before_distance{bit_buffer};
+          bit_buffer >>= distance_entry & 0x3fU;
+          bits_available -= distance_entry;
+          const std::size_t distance{
+              (distance_entry >> 16) +
+              (low_bits(buffer_before_distance, distance_entry & 0x1fU) >>
+               ((distance_entry >> 8) & 0x1fU))};
+
+          if (std::cmp_greater(distance, output_next - history_start)) {
+            throw GZIPError{"Backref distance exceeds bytes available"};
+          }
+
+          // A match leaves too few bits for the next lookup, so refill and
+          // load the next entry before copying, which keeps a mispredicted
+          // copy loop from holding back the decoding that follows
+          bit_buffer |= load_word(input_next) << (bits_available & 63U);
+          input_next += (63U - (bits_available & 63U)) >> 3;
+          bits_available |= 56;
+          entry = literal_length_table[low_bits(
+              bit_buffer, INFLATE_LITERAL_LENGTH_TABLE_BITS)];
+
+          // Whole chunks may run past the end of the match, which the
+          // output margin leaves room for. Most matches fit in the chunks
+          // copied before the loop, so its branch is rarely taken
+          auto *destination{output_next};
+          const auto *source{output_next - distance};
+          output_next += length;
+          if (distance >= 16) {
+            std::memcpy(destination, source, 16);
+            std::memcpy(destination + 16, source + 16, 16);
+            std::memcpy(destination + 32, source + 32, 16);
+            destination += 48;
+            source += 48;
+            while (destination < output_next) {
+              std::memcpy(destination, source, 16);
+              destination += 16;
+              source += 16;
+            }
+          } else if (distance >= 8) {
+            std::memcpy(destination, source, 8);
+            std::memcpy(destination + 8, source + 8, 8);
+            std::memcpy(destination + 16, source + 16, 8);
+            std::memcpy(destination + 24, source + 24, 8);
+            std::memcpy(destination + 32, source + 32, 8);
+            destination += 40;
+            source += 40;
+            while (destination < output_next) {
+              std::memcpy(destination, source, 8);
+              destination += 8;
+              source += 8;
+            }
+          } else if (distance == 1) {
+            const std::uint64_t pattern{0x0101010101010101ULL * *source};
+            std::memcpy(destination, &pattern, 8);
+            std::memcpy(destination + 8, &pattern, 8);
+            std::memcpy(destination + 16, &pattern, 8);
+            std::memcpy(destination + 24, &pattern, 8);
+            destination += 32;
+            while (destination < output_next) {
+              std::memcpy(destination, &pattern, 8);
+              destination += 8;
+            }
+          } else {
+            // Once one whole step of the repeating pattern is written,
+            // the rest is a word copy from that far back
+            const auto step{SHORT_DISTANCE_STEP[distance]};
+            const auto *const expanded{destination + step};
+            while (destination < expanded) {
+              *destination++ = *source++;
+            }
+
+            while (destination < output_next) {
+              std::memcpy(destination, destination - step, 8);
+              destination += 8;
+            }
+          }
+
+          if (input_next >= input_limit || output_next >= output_limit) {
+            break;
+          }
+
+          continue;
+        }
+
+        if (input_next >= input_limit || output_next >= output_limit) {
+          break;
+        }
+
+        bit_buffer |= load_word(input_next) << (bits_available & 63U);
+        input_next += (63U - (bits_available & 63U)) >> 3;
+        bits_available |= 56;
+        entry = literal_length_table[low_bits(
+            bit_buffer, INFLATE_LITERAL_LENGTH_TABLE_BITS)];
+      }
+    }
+
+    buffers.input_next = input_next;
+    buffers.output_next = output_next;
+    this->bit_buffer_ = bit_buffer;
+    this->bits_available_ = bits_available & 63U;
+    if (block_ended) {
+      this->end_block(buffers);
+    }
+
+    return block_ended;
+  }
+
+  auto decode_huffman_careful(InflateBuffers &buffers) -> InflateStatus {
+    while (true) {
+      if (!buffers.input_final && available_input(buffers) < 8) {
+        return InflateStatus::NeedInput;
+      }
+
+      this->refill_careful(buffers);
+      auto entry{this->literal_length_table_[low_bits(
+          this->bit_buffer_, INFLATE_LITERAL_LENGTH_TABLE_BITS)]};
+      unsigned int prefix{0};
+      if ((entry & INFLATE_ENTRY_SUBTABLE) != 0) {
+        prefix = INFLATE_LITERAL_LENGTH_TABLE_BITS;
+        entry = this->literal_length_table_
+                    [(entry >> 16) +
+                     low_bits(this->bit_buffer_ >> prefix,
+                              INFLATE_MAXIMUM_CODEWORD_LENGTH -
+                                  INFLATE_LITERAL_LENGTH_TABLE_BITS)];
+      }
+
+      if ((entry & INFLATE_ENTRY_INVALID_CODE) != 0) {
+        this->fail("Invalid Huffman code", INFLATE_MAXIMUM_CODEWORD_LENGTH);
+      }
+
+      const unsigned int consumed{prefix + (entry & 0x1fU)};
+      if ((entry & INFLATE_ENTRY_INVALID_SYMBOL) != 0) {
+        this->fail("Invalid literal/length code", consumed);
+      }
+
+      if ((entry & INFLATE_ENTRY_END_OF_BLOCK) != 0) {
+        this->consume(consumed);
+        this->check_not_overread();
+        this->end_block(buffers);
+        return InflateStatus::Done;
+      }
+
+      // Nothing past the end of the block needs output space, so only a
+      // literal or a match makes a full output buffer suspend the decoder
+      if (available_output(buffers) == 0) {
+        return InflateStatus::OutputFull;
+      }
+
+      if ((entry & INFLATE_ENTRY_LITERAL) != 0) {
+        this->consume(consumed);
+        this->check_not_overread();
+        *buffers.output_next++ = static_cast<std::uint8_t>(entry >> 16);
+        continue;
+      }
+
+      const unsigned int length_codeword{prefix + ((entry >> 8) & 0x1fU)};
+      const std::size_t length{(entry >> 16) +
+                               low_bits(this->bit_buffer_ >> length_codeword,
+                                        consumed - length_codeword)};
+      this->consume(consumed);
+
+      auto distance_entry{this->distance_table_[low_bits(
+          this->bit_buffer_, INFLATE_DISTANCE_TABLE_BITS)]};
+      unsigned int distance_prefix{0};
+      if ((distance_entry & INFLATE_ENTRY_SUBTABLE) != 0) {
+        distance_prefix = INFLATE_DISTANCE_TABLE_BITS;
+        distance_entry =
+            this->distance_table_[(distance_entry >> 16) +
+                                  low_bits(this->bit_buffer_ >> distance_prefix,
+                                           INFLATE_MAXIMUM_CODEWORD_LENGTH -
+                                               INFLATE_DISTANCE_TABLE_BITS)];
+      }
+
+      if ((distance_entry & INFLATE_ENTRY_INVALID_CODE) != 0) {
+        this->fail("Invalid Huffman code", INFLATE_MAXIMUM_CODEWORD_LENGTH);
+      }
+
+      const unsigned int distance_consumed{distance_prefix +
+                                           (distance_entry & 0x1fU)};
+      if ((distance_entry & INFLATE_ENTRY_INVALID_SYMBOL) != 0) {
+        this->fail("Invalid distance code", distance_consumed);
+      }
+
+      const unsigned int distance_codeword{distance_prefix +
+                                           ((distance_entry >> 8) & 0x1fU)};
+      const std::size_t distance{
+          (distance_entry >> 16) +
+          low_bits(this->bit_buffer_ >> distance_codeword,
+                   distance_consumed - distance_codeword)};
+      this->consume(distance_consumed);
+      this->check_not_overread();
+
+      if (std::cmp_greater(distance,
+                           buffers.output_next - this->history_start_)) {
+        throw GZIPError{"Backref distance exceeds bytes available"};
+      }
+
+      this->pending_length_ = length;
+      this->pending_distance_ = distance;
+      if (this->copy_match_careful(buffers) != InflateStatus::Done) {
+        return InflateStatus::OutputFull;
+      }
+    }
+  }
+
+  State state_{State::MemberStart};
+  bool first_member_{true};
+  bool final_block_{false};
+  bool fixed_tables_{false};
+  std::uint8_t flags_{0};
+  std::uint64_t bit_buffer_{0};
+  unsigned int bits_available_{0};
+  unsigned int overread_{0};
+  std::size_t skip_remaining_{0};
+  std::size_t stored_remaining_{0};
+  std::size_t pending_length_{0};
+  std::size_t pending_distance_{0};
+  std::uint32_t header_checksum_{0};
+  std::uint32_t member_checksum_{0};
+  std::uint32_t member_size_{0};
+  std::size_t member_history_{0};
+  const std::uint8_t *checksum_position_{nullptr};
+  const std::uint8_t *history_start_{nullptr};
+  // Every table is built before it is read, so zeroing them upfront would
+  // only slow down every construction
+  // NOLINTBEGIN(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
+  std::array<std::uint32_t, INFLATE_LITERAL_LENGTH_TABLE_SIZE>
+      literal_length_table_;
+  std::array<std::uint32_t, INFLATE_DISTANCE_TABLE_SIZE> distance_table_;
+  std::array<std::uint32_t, INFLATE_CODE_LENGTH_TABLE_SIZE> code_length_table_;
+  // NOLINTEND(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
+};
+
+} // namespace sourcemeta::core
+
+#endif
diff --git a/vendor/core/src/core/gzip/streambuf.cc b/vendor/core/src/core/gzip/streambuf.cc
index 15c318e3..1ac89100 100644
--- a/vendor/core/src/core/gzip/streambuf.cc
+++ b/vendor/core/src/core/gzip/streambuf.cc
@@ -1,152 +1,55 @@
 #include <sourcemeta/core/gzip.h>
 
-#include "bit_reader.h"
-#include "deflate.h"
+#include "inflate.h"
 
-#include <sourcemeta/core/crypto.h>
-
-#include <array>       // std::array
-#include <cstddef>     // std::size_t, std::ptrdiff_t
-#include <cstdint>     // std::uint8_t, std::uint16_t, std::uint32_t
-#include <istream>     // std::istream
-#include <string_view> // std::string_view
+#include <cstddef> // std::size_t
+#include <cstdint> // std::uint8_t
+#include <cstring> // std::memmove
+#include <ios>     // std::streamsize
+#include <istream> // std::istream
+#include <vector>  // std::vector
 
 namespace sourcemeta::core {
 
-static constexpr std::size_t GZIP_BUFFER_SIZE{16384};
+static constexpr std::size_t GZIP_INPUT_BUFFER_SIZE{65536};
+static constexpr std::size_t GZIP_OUTPUT_BUFFER_SIZE{262144};
+// RFC 1951 section 3.2.5 caps the distance of a back-reference
+static constexpr std::size_t GZIP_HISTORY_SIZE{32768};
 
 struct GZIPStreamBuffer::Internal {
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
   std::istream &stream;
-  BitReader reader;
-  DeflateDecoder deflate;
+  InflateDecoder decoder;
+  std::vector<std::uint8_t> input;
+  std::vector<std::uint8_t> output;
+  std::size_t input_next{0};
+  std::size_t input_end{0};
+  std::size_t output_next{0};
+  bool input_final{false};
   bool stream_ended{false};
-  bool any_member_completed{false};
-  bool member_started{false};
-  std::uint32_t member_crc32{0};
-  std::uint32_t member_isize{0};
-  std::array<std::uint8_t, GZIP_BUFFER_SIZE> decompressed_buffer{};
 
   Internal(std::istream &source)
-      : stream{source}, reader{source}, deflate{reader} {}
-};
-
-namespace {
-
-// Accumulates the running CRC-32 over the header bytes that the FHCRC check
-// covers, computing it only when the FHCRC flag is present
-class HeaderChecksum {
-public:
-  HeaderChecksum(const bool track) : track_{track} {}
-
-  auto feed(const std::uint8_t byte) -> void {
-    if (this->track_) {
-      const auto data{static_cast<char>(byte)};
-      this->checksum_ =
-          crc32_update(this->checksum_, std::string_view{&data, 1});
+      : stream{source}, input(GZIP_INPUT_BUFFER_SIZE),
+        output(GZIP_OUTPUT_BUFFER_SIZE) {}
+
+  // The bytes the decoder already moved into its bit buffer stay in place, as
+  // the decoder may hand them back to the input
+  auto refill() -> void {
+    const auto keep{this->input_next - this->decoder.buffered_input()};
+    std::memmove(this->input.data(), this->input.data() + keep,
+                 this->input_end - keep);
+    this->input_end -= keep;
+    this->input_next -= keep;
+    this->stream.read(
+        reinterpret_cast<char *>(this->input.data() + this->input_end),
+        static_cast<std::streamsize>(GZIP_INPUT_BUFFER_SIZE - this->input_end));
+    this->input_end += static_cast<std::size_t>(this->stream.gcount());
+    if (!this->stream) {
+      this->input_final = true;
     }
   }
-
-  [[nodiscard]] auto low16() const -> std::uint16_t {
-    return static_cast<std::uint16_t>(this->checksum_ & 0xffffU);
-  }
-
-private:
-  bool track_;
-  std::uint32_t checksum_{0};
 };
 
-auto read_header_byte(BitReader &reader, HeaderChecksum &checksum)
-    -> std::uint8_t {
-  const auto byte{reader.read_byte()};
-  checksum.feed(byte);
-  return byte;
-}
-
-auto parse_member_header(BitReader &reader, const std::uint8_t first_byte)
-    -> void {
-  // RFC 1952 section 2.3.1.2: FHCRC covers every header byte up to but not
-  // including the CRC16 itself, so feeding each byte as it is read produces
-  // exactly the right value. The bytes are not retained, removing an
-  // unbounded-memory path through FNAME and FCOMMENT
-
-  // Caller already consumed the ID1 byte and verified it is 0x1f
-  const auto id2{reader.read_byte()};
-  if (id2 != 0x8b) {
-    throw GZIPError{"Invalid gzip magic bytes"};
-  }
-  const auto compression_method{reader.read_byte()};
-  if (compression_method != 8) {
-    throw GZIPError{"Unsupported gzip compression method"};
-  }
-  const auto flag_byte{reader.read_byte()};
-  if ((flag_byte & 0xe0) != 0) {
-    throw GZIPError{"Reserved gzip FLG bits must be zero"};
-  }
-
-  HeaderChecksum checksum{(flag_byte & 0x02) != 0};
-  checksum.feed(first_byte);
-  checksum.feed(id2);
-  checksum.feed(compression_method);
-  checksum.feed(flag_byte);
-
-  // MTIME (4 bytes) + XFL (1 byte) + OS (1 byte) are informational
-  for (std::size_t index = 0; index < 6; ++index) {
-    read_header_byte(reader, checksum);
-  }
-
-  if ((flag_byte & 0x04) != 0) {
-    // FEXTRA
-    const auto xlen_lo{read_header_byte(reader, checksum)};
-    const auto xlen_hi{read_header_byte(reader, checksum)};
-    const auto xlen{static_cast<std::size_t>(xlen_lo) |
-                    (static_cast<std::size_t>(xlen_hi) << 8)};
-    for (std::size_t index = 0; index < xlen; ++index) {
-      read_header_byte(reader, checksum);
-    }
-  }
-
-  if ((flag_byte & 0x08) != 0) {
-    // FNAME (null-terminated)
-    while (read_header_byte(reader, checksum) != 0) {
-    }
-  }
-
-  if ((flag_byte & 0x10) != 0) {
-    // FCOMMENT (null-terminated)
-    while (read_header_byte(reader, checksum) != 0) {
-    }
-  }
-
-  if ((flag_byte & 0x02) != 0) {
-    // FHCRC: low 16 bits of CRC-32 over all preceding header bytes
-    const auto stored_lo{reader.read_byte()};
-    const auto stored_hi{reader.read_byte()};
-    const std::uint16_t stored{static_cast<std::uint16_t>(
-        static_cast<std::uint16_t>(stored_lo) |
-        static_cast<std::uint16_t>(static_cast<std::uint16_t>(stored_hi)
-                                   << 8))};
-    if (stored != checksum.low16()) {
-      throw GZIPError{"FHCRC mismatch"};
-    }
-  }
-}
-
-// Used for members past the first, where gzip(1) tolerates trailing
-// non-member data, so a header that fails to validate is reported as
-// trailing garbage rather than propagated as an error
-auto try_parse_member_header(BitReader &reader, const std::uint8_t first_byte)
-    -> bool {
-  try {
-    parse_member_header(reader, first_byte);
-    return true;
-  } catch (const GZIPError &) {
-    return false;
-  }
-}
-
-} // namespace
-
 GZIPStreamBuffer::GZIPStreamBuffer(std::istream &compressed_stream)
     : internal_{new Internal{compressed_stream}} {}
 
@@ -156,86 +59,47 @@ auto GZIPStreamBuffer::underflow() -> int_type {
   if ((this->gptr() != nullptr) && this->gptr() < this->egptr()) {
     return traits_type::to_int_type(*this->gptr());
   }
-  if (this->internal_->stream_ended) {
-    return traits_type::eof();
-  }
-
-  while (true) {
-    if (!this->internal_->member_started) {
-      std::uint8_t first_byte{0};
-      if (!this->internal_->reader.try_read_byte(first_byte)) {
-        if (!this->internal_->any_member_completed) {
-          throw GZIPError{"Empty source stream"};
-        }
-        this->internal_->stream_ended = true;
-        return traits_type::eof();
-      }
-      if (this->internal_->any_member_completed) {
-        // gzip(1) silently ignores any trailing data after a complete member
-        // rather than treating it as the start of a new member. Bytes that do
-        // not form a valid member header end the stream without error,
-        // independent of the first byte value
-        if (first_byte != 0x1f ||
-            !try_parse_member_header(this->internal_->reader, first_byte)) {
-          this->internal_->stream_ended = true;
-          return traits_type::eof();
-        }
-      } else {
-        if (first_byte != 0x1f) {
-          throw GZIPError{"Invalid gzip magic bytes"};
-        }
-        parse_member_header(this->internal_->reader, first_byte);
-      }
 
-      this->internal_->deflate.reset();
-      this->internal_->member_started = true;
-      this->internal_->member_crc32 = 0;
-      this->internal_->member_isize = 0;
+  auto &internal{*this->internal_};
+  while (!internal.stream_ended) {
+    if (GZIP_OUTPUT_BUFFER_SIZE - internal.output_next < GZIP_HISTORY_SIZE) {
+      std::memmove(internal.output.data(),
+                   internal.output.data() + internal.output_next -
+                       GZIP_HISTORY_SIZE,
+                   GZIP_HISTORY_SIZE);
+      internal.output_next = GZIP_HISTORY_SIZE;
     }
 
-    const auto produced{this->internal_->deflate.decompress(
-        this->internal_->decompressed_buffer.data(),
-        this->internal_->decompressed_buffer.size())};
-
-    if (produced > 0) {
-      this->internal_->member_crc32 = crc32_update(
-          this->internal_->member_crc32,
-          std::string_view{reinterpret_cast<const char *>(
-                               this->internal_->decompressed_buffer.data()),
-                           produced});
-      this->internal_->member_isize += static_cast<std::uint32_t>(produced);
-
-      auto *buffer_start{reinterpret_cast<char *>(
-          this->internal_->decompressed_buffer.data())};
-      this->setg(buffer_start, buffer_start,
-                 buffer_start + static_cast<std::ptrdiff_t>(produced));
-      return traits_type::to_int_type(*this->gptr());
+    const auto produced_start{internal.output_next};
+    InflateBuffers buffers{
+        .input_next = internal.input.data() + internal.input_next,
+        .input_end = internal.input.data() + internal.input_end,
+        .input_final = internal.input_final,
+        .output_begin = internal.output.data(),
+        .output_next = internal.output.data() + internal.output_next,
+        .output_end = internal.output.data() + GZIP_OUTPUT_BUFFER_SIZE};
+    const auto status{internal.decoder.decode(buffers)};
+    internal.input_next =
+        static_cast<std::size_t>(buffers.input_next - internal.input.data());
+    internal.output_next =
+        static_cast<std::size_t>(buffers.output_next - internal.output.data());
+    if (status == InflateStatus::Done) {
+      internal.stream_ended = true;
+    } else if (status == InflateStatus::NeedInput) {
+      internal.refill();
     }
 
-    if (!this->internal_->deflate.stream_ended()) {
-      throw GZIPError{"Deflate stream ended unexpectedly"};
-    }
-
-    std::array<std::uint8_t, 8> trailer{};
-    this->internal_->reader.read_bytes(trailer.data(), trailer.size());
-    const auto stored_crc32{static_cast<std::uint32_t>(trailer[0]) |
-                            (static_cast<std::uint32_t>(trailer[1]) << 8) |
-                            (static_cast<std::uint32_t>(trailer[2]) << 16) |
-                            (static_cast<std::uint32_t>(trailer[3]) << 24)};
-    const auto stored_isize{static_cast<std::uint32_t>(trailer[4]) |
-                            (static_cast<std::uint32_t>(trailer[5]) << 8) |
-                            (static_cast<std::uint32_t>(trailer[6]) << 16) |
-                            (static_cast<std::uint32_t>(trailer[7]) << 24)};
-    if (stored_crc32 != this->internal_->member_crc32) {
-      throw GZIPError{"Gzip member CRC32 mismatch"};
-    }
-    if (stored_isize != this->internal_->member_isize) {
-      throw GZIPError{"Gzip member ISIZE mismatch"};
+    if (internal.output_next > produced_start) {
+      auto *const start{
+          reinterpret_cast<char *>(internal.output.data() + produced_start)};
+      this->setg(start, start,
+                 reinterpret_cast<char *>(internal.output.data() +
+                                          internal.output_next));
+      return traits_type::to_int_type(*this->gptr());
     }
-
-    this->internal_->any_member_completed = true;
-    this->internal_->member_started = false;
   }
+
+  return traits_type::eof();
 }
 
 } // namespace sourcemeta::core
diff --git a/vendor/core/src/core/html/CMakeLists.txt b/vendor/core/src/core/html/CMakeLists.txt
index 60855893..7621dc44 100644
--- a/vendor/core/src/core/html/CMakeLists.txt
+++ b/vendor/core/src/core/html/CMakeLists.txt
@@ -1,6 +1,34 @@
+# Codegen
+set(SOURCEMETA_CORE_HTML_ENTITIES_PATH
+  "${core_SOURCE_DIR}/vendor/whatwg-html-build/entities/out/entities.json")
+set(SOURCEMETA_CORE_HTML_ENTITIES_HEADER
+  "${CMAKE_CURRENT_BINARY_DIR}/html_entities.h")
+sourcemeta_executable(NAMESPACE sourcemeta PROJECT core NAME html_codegen
+  OUTPUT SOURCEMETA_CORE_HTML_CODEGEN_TARGET
+  SOURCES codegen.cc entity_hash.h)
+target_link_libraries("${SOURCEMETA_CORE_HTML_CODEGEN_TARGET}" PRIVATE
+  sourcemeta::core::io
+  sourcemeta::core::json
+  sourcemeta::core::options
+  sourcemeta::core::unicode)
+add_custom_command(
+  OUTPUT "${SOURCEMETA_CORE_HTML_ENTITIES_HEADER}"
+  COMMAND "${SOURCEMETA_CORE_HTML_CODEGEN_TARGET}"
+    "${SOURCEMETA_CORE_HTML_ENTITIES_HEADER}"
+    "${SOURCEMETA_CORE_HTML_ENTITIES_PATH}"
+  DEPENDS
+    "${SOURCEMETA_CORE_HTML_CODEGEN_TARGET}"
+    "${SOURCEMETA_CORE_HTML_ENTITIES_PATH}"
+  COMMENT "Generating HTML named character references"
+  VERBATIM)
+
 sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME html
-  PRIVATE_HEADERS buffer.h escape.h writer.h
-  SOURCES escape.cc writer.cc)
+  PRIVATE_HEADERS buffer.h entity.h escape.h writer.h
+  SOURCES entity.cc entity_hash.h escape.cc writer.cc
+    "${SOURCEMETA_CORE_HTML_ENTITIES_HEADER}")
+
+target_include_directories(sourcemeta_core_html PRIVATE
+  "${CMAKE_CURRENT_BINARY_DIR}")
 
 if(SOURCEMETA_CORE_INSTALL)
   sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME html)
diff --git a/vendor/core/src/core/html/codegen.cc b/vendor/core/src/core/html/codegen.cc
new file mode 100644
index 00000000..6a5fa311
--- /dev/null
+++ b/vendor/core/src/core/html/codegen.cc
@@ -0,0 +1,293 @@
+#include <sourcemeta/core/io.h>
+#include <sourcemeta/core/json.h>
+#include <sourcemeta/core/options.h>
+#include <sourcemeta/core/unicode.h>
+
+#include "entity_hash.h"
+
+#include <algorithm> // std::max, std::ranges::find, std::ranges::stable_sort
+#include <cstddef>   // std::size_t
+#include <cstdint> // std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t
+#include <cstdlib> // EXIT_FAILURE, EXIT_SUCCESS
+#include <exception>   // std::exception
+#include <filesystem>  // std::filesystem::path
+#include <ios>         // std::hex, std::uppercase, std::dec
+#include <iostream>    // std::cerr
+#include <numeric>     // std::iota
+#include <optional>    // std::optional, std::nullopt
+#include <ostream>     // std::ostream
+#include <stdexcept>   // std::runtime_error
+#include <string>      // std::string
+#include <string_view> // std::string_view, std::string_view_literals
+#include <utility>     // std::move
+#include <vector>      // std::vector
+
+namespace {
+
+using namespace std::string_view_literals;
+
+constexpr auto HASH_CODEPOINTS{
+    sourcemeta::core::JSON::Object::hash("codepoints"sv)};
+
+constexpr std::size_t CHARACTERS_CAPACITY{8};
+constexpr std::uint64_t MAXIMUM_SEED_ATTEMPTS{1000};
+constexpr std::uint32_t MAXIMUM_DISPLACEMENT{0xFFFF};
+// Every bucket holds this many names on average
+constexpr std::uint32_t BUCKET_SIZE{3};
+
+struct Entity {
+  std::string name;
+  std::string characters;
+};
+
+struct PerfectHash {
+  std::uint64_t seed;
+  std::uint32_t buckets;
+  std::vector<std::uint16_t> displacements;
+  std::vector<std::uint32_t> slots;
+};
+
+auto parse_entities(const std::filesystem::path &input_path)
+    -> std::vector<Entity> {
+  const auto document{sourcemeta::core::read_json(input_path)};
+  if (!document.is_object()) {
+    throw std::runtime_error{"The entities must be an object"};
+  }
+
+  std::vector<Entity> result;
+  result.reserve(document.object_size());
+  for (const auto &entry : document.as_object()) {
+    const auto &key{entry.first};
+    const auto *codepoints{
+        entry.second.is_object()
+            ? entry.second.try_at("codepoints"sv, HASH_CODEPOINTS)
+            : nullptr};
+    if (key.size() < 2 || key.front() != '&' || codepoints == nullptr ||
+        !codepoints->is_array()) {
+      throw std::runtime_error{"Invalid entity definition"};
+    }
+
+    Entity entity{.name = std::string{key.data() + 1, key.size() - 1},
+                  .characters = {}};
+    for (const auto &codepoint : codepoints->as_array()) {
+      if (!codepoint.is_integer() || codepoint.to_integer() < 0 ||
+          codepoint.to_integer() > 0x10FFFF ||
+          !sourcemeta::core::is_valid_codepoint(
+              static_cast<char32_t>(codepoint.to_integer()))) {
+        throw std::runtime_error{
+            std::string{"Invalid codepoint in entity: "}.append(entity.name)};
+      }
+
+      sourcemeta::core::codepoint_to_utf8(
+          static_cast<char32_t>(codepoint.to_integer()), entity.characters);
+    }
+
+    if (entity.characters.empty() ||
+        entity.characters.size() > CHARACTERS_CAPACITY) {
+      throw std::runtime_error{
+          std::string{"Invalid characters in entity: "}.append(entity.name)};
+    }
+
+    result.push_back(std::move(entity));
+  }
+
+  if (result.empty()) {
+    throw std::runtime_error{"No entities found"};
+  }
+
+  return result;
+}
+
+// A displacement that sends every name of a bucket to a different free slot
+auto find_displacement(const std::vector<std::uint64_t> &hashes,
+                       const std::vector<std::size_t> &members,
+                       const std::vector<bool> &occupied,
+                       const std::uint32_t slot_count,
+                       std::vector<std::uint32_t> &candidates)
+    -> std::optional<std::uint16_t> {
+  for (std::uint32_t displacement{0}; displacement <= MAXIMUM_DISPLACEMENT;
+       ++displacement) {
+    candidates.clear();
+    bool valid{true};
+    for (const auto member : members) {
+      const auto slot{sourcemeta::core::html_entity_slot(
+          hashes[member], displacement, slot_count)};
+      if (occupied[slot] ||
+          std::ranges::find(candidates, slot) != candidates.end()) {
+        valid = false;
+        break;
+      }
+
+      candidates.push_back(slot);
+    }
+
+    if (valid) {
+      return static_cast<std::uint16_t>(displacement);
+    }
+  }
+
+  return std::nullopt;
+}
+
+// A minimal perfect hash of the names, placing the largest buckets first while
+// most slots are still free
+auto build_perfect_hash(const std::vector<Entity> &entries) -> PerfectHash {
+  const auto slot_count{static_cast<std::uint32_t>(entries.size())};
+  const auto bucket_count{(slot_count + BUCKET_SIZE - 1) / BUCKET_SIZE};
+  std::vector<std::uint64_t> hashes(entries.size(), 0);
+  std::vector<std::uint32_t> candidates;
+  for (std::uint64_t seed{0}; seed < MAXIMUM_SEED_ATTEMPTS; ++seed) {
+    std::vector<std::vector<std::size_t>> members(bucket_count);
+    for (std::size_t index{0}; index < entries.size(); ++index) {
+      hashes[index] =
+          sourcemeta::core::html_entity_hash(entries[index].name, seed);
+      members[sourcemeta::core::html_entity_bucket(hashes[index], bucket_count)]
+          .push_back(index);
+    }
+
+    std::vector<std::uint32_t> order(bucket_count, 0);
+    std::iota(order.begin(), order.end(), 0);
+    std::ranges::stable_sort(
+        order, [&members](const std::uint32_t left, const std::uint32_t right) {
+          return members[left].size() > members[right].size();
+        });
+
+    PerfectHash result{.seed = seed,
+                       .buckets = bucket_count,
+                       .displacements =
+                           std::vector<std::uint16_t>(bucket_count, 0),
+                       .slots = std::vector<std::uint32_t>(entries.size(), 0)};
+    std::vector<bool> occupied(slot_count, false);
+    bool complete{true};
+    for (const auto bucket : order) {
+      if (members[bucket].empty()) {
+        break;
+      }
+
+      const auto displacement{find_displacement(
+          hashes, members[bucket], occupied, slot_count, candidates)};
+      if (!displacement.has_value()) {
+        complete = false;
+        break;
+      }
+
+      result.displacements[bucket] = displacement.value();
+      for (const auto member : members[bucket]) {
+        const auto slot{sourcemeta::core::html_entity_slot(
+            hashes[member], displacement.value(), slot_count)};
+        occupied[slot] = true;
+        result.slots[member] = slot;
+      }
+    }
+
+    if (complete) {
+      return result;
+    }
+  }
+
+  throw std::runtime_error{"Could not build a perfect hash of the entities"};
+}
+
+auto emit_byte(std::ostream &stream, const char character) -> void {
+  stream << "'\\x" << std::hex << std::uppercase
+         << static_cast<unsigned int>(static_cast<unsigned char>(character))
+         << std::dec << "'";
+}
+
+auto emit_entities(std::ostream &stream, const std::vector<Entity> &entries,
+                   const PerfectHash &table) -> void {
+  std::vector<std::size_t> by_slot(entries.size(), 0);
+  std::size_t maximum_name_length{0};
+  for (std::size_t index{0}; index < entries.size(); ++index) {
+    by_slot[table.slots[index]] = index;
+    maximum_name_length =
+        std::max(maximum_name_length, entries[index].name.size());
+  }
+
+  stream << "#include <cstddef>\n";
+  stream << "#include <cstdint>\n\n";
+  stream << "namespace {\n\n";
+  stream << "constexpr std::uint64_t HTML_ENTITY_SEED{" << table.seed << "};\n";
+  stream << "constexpr std::uint32_t HTML_ENTITY_BUCKETS{" << table.buckets
+         << "};\n";
+  stream << "constexpr std::uint32_t HTML_ENTITY_COUNT{" << entries.size()
+         << "};\n";
+  stream << "constexpr std::size_t HTML_ENTITY_MAXIMUM_NAME_LENGTH{"
+         << maximum_name_length << "};\n\n";
+
+  stream << "constexpr std::uint16_t HTML_ENTITY_DISPLACEMENTS["
+         << table.buckets << "] = {\n";
+  for (std::size_t index{0}; index < table.displacements.size(); ++index) {
+    stream << (index % 16 == 0 ? "    " : " ") << table.displacements[index]
+           << ",";
+    if (index % 16 == 15 || index + 1 == table.displacements.size()) {
+      stream << "\n";
+    }
+  }
+  stream << "};\n\n";
+
+  stream << "constexpr char HTML_ENTITY_NAMES[] =\n";
+  std::size_t offset{0};
+  std::vector<std::size_t> offsets(entries.size(), 0);
+  for (const auto index : by_slot) {
+    offsets[index] = offset;
+    stream << "    \"" << entries[index].name << "\"\n";
+    offset += entries[index].name.size();
+  }
+  stream << "    ;\n\n";
+  if (offset > 0xFFFF) {
+    throw std::runtime_error{"Entity names do not fit in the offsets"};
+  }
+
+  stream << "struct HTMLEntityEntry {\n"
+         << "  std::uint16_t name_offset;\n"
+         << "  std::uint8_t name_length;\n"
+         << "  std::uint8_t characters_length;\n"
+         << "  char characters[" << CHARACTERS_CAPACITY << "];\n"
+         << "};\n\n";
+  stream << "constexpr HTMLEntityEntry HTML_ENTITIES[" << entries.size()
+         << "] = {\n";
+  for (const auto index : by_slot) {
+    const auto &entry{entries[index]};
+    stream << "    {" << offsets[index] << ", " << entry.name.size() << ", "
+           << entry.characters.size() << ", {";
+    for (std::size_t position{0}; position < entry.characters.size();
+         ++position) {
+      if (position > 0) {
+        stream << ", ";
+      }
+
+      emit_byte(stream, entry.characters[position]);
+    }
+    stream << "}},\n";
+  }
+  stream << "};\n\n";
+  stream << "} // namespace\n";
+}
+
+} // namespace
+
+auto main(const int argc, const char *const argv[]) -> int {
+  try {
+    sourcemeta::core::Options app;
+    app.parse(argc, argv);
+    const auto &positional{app.positional()};
+    if (positional.size() != 2) {
+      std::cerr << "Usage: " << (argc > 0 ? argv[0] : "codegen")
+                << " <output.h> <entities.json>\n";
+      return EXIT_FAILURE;
+    }
+
+    const std::filesystem::path output_path{positional.at(0)};
+    const auto entries{parse_entities(positional.at(1))};
+    const auto table{build_perfect_hash(entries)};
+    sourcemeta::core::write_file(output_path, [&](std::ostream &stream) {
+      emit_entities(stream, entries, table);
+    });
+  } catch (const std::exception &error) {
+    std::cerr << "codegen: " << error.what() << "\n";
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/vendor/core/src/core/html/entity.cc b/vendor/core/src/core/html/entity.cc
new file mode 100644
index 00000000..efdce97d
--- /dev/null
+++ b/vendor/core/src/core/html/entity.cc
@@ -0,0 +1,30 @@
+#include <sourcemeta/core/html_entity.h>
+
+#include "entity_hash.h"
+#include "html_entities.h"
+
+#include <cstring>     // std::memcmp
+#include <string_view> // std::string_view
+
+namespace sourcemeta::core {
+
+auto html_entity(const std::string_view name) noexcept -> std::string_view {
+  if (name.empty() || name.size() > HTML_ENTITY_MAXIMUM_NAME_LENGTH) {
+    return {};
+  }
+
+  const auto hash{html_entity_hash(name, HTML_ENTITY_SEED)};
+  const auto displacement{
+      HTML_ENTITY_DISPLACEMENTS[html_entity_bucket(hash, HTML_ENTITY_BUCKETS)]};
+  const auto &entry{
+      HTML_ENTITIES[html_entity_slot(hash, displacement, HTML_ENTITY_COUNT)]};
+  if (entry.name_length != name.size() ||
+      std::memcmp(HTML_ENTITY_NAMES + entry.name_offset, name.data(),
+                  name.size()) != 0) {
+    return {};
+  }
+
+  return {entry.characters, entry.characters_length};
+}
+
+} // namespace sourcemeta::core
diff --git a/vendor/core/src/core/html/entity_hash.h b/vendor/core/src/core/html/entity_hash.h
new file mode 100644
index 00000000..5d4537bb
--- /dev/null
+++ b/vendor/core/src/core/html/entity_hash.h
@@ -0,0 +1,58 @@
+#ifndef SOURCEMETA_CORE_HTML_ENTITY_HASH_H_
+#define SOURCEMETA_CORE_HTML_ENTITY_HASH_H_
+
+#include <cstdint>     // std::uint32_t, std::uint64_t
+#include <string_view> // std::string_view
+
+// The perfect hash of the named character references, shared by the code
+// generator that builds the table and the lookup that reads it. The upper half
+// of the hash of a name picks a bucket, and the lower half, mixed with the
+// displacement that the generator chose for that bucket, picks the slot
+
+namespace sourcemeta::core {
+
+inline auto html_entity_hash(const std::string_view name,
+                             const std::uint64_t seed) noexcept
+    -> std::uint64_t {
+  std::uint64_t hash{0xCBF29CE484222325ULL ^ seed};
+  for (const auto character : name) {
+    hash ^= static_cast<unsigned char>(character);
+    hash *= 0x100000001B3ULL;
+  }
+
+  hash ^= hash >> 33U;
+  hash *= 0xFF51AFD7ED558CCDULL;
+  hash ^= hash >> 33U;
+  return hash;
+}
+
+// Map a value onto a range with a multiplication instead of a division
+inline auto html_entity_reduce(const std::uint32_t value,
+                               const std::uint32_t range) noexcept
+    -> std::uint32_t {
+  return static_cast<std::uint32_t>(
+      (static_cast<std::uint64_t>(value) * range) >> 32U);
+}
+
+inline auto html_entity_bucket(const std::uint64_t hash,
+                               const std::uint32_t buckets) noexcept
+    -> std::uint32_t {
+  return html_entity_reduce(static_cast<std::uint32_t>(hash >> 32U), buckets);
+}
+
+inline auto html_entity_slot(const std::uint64_t hash,
+                             const std::uint32_t displacement,
+                             const std::uint32_t slots) noexcept
+    -> std::uint32_t {
+  auto value{static_cast<std::uint32_t>(hash) ^ (displacement * 0x9E3779B9U)};
+  value ^= value >> 16U;
+  value *= 0x85EBCA6BU;
+  value ^= value >> 13U;
+  value *= 0xC2B2AE35U;
+  value ^= value >> 16U;
+  return html_entity_reduce(value, slots);
+}
+
+} // namespace sourcemeta::core
+
+#endif
diff --git a/vendor/core/src/core/html/include/sourcemeta/core/html.h b/vendor/core/src/core/html/include/sourcemeta/core/html.h
index 23853c6c..cc372deb 100644
--- a/vendor/core/src/core/html/include/sourcemeta/core/html.h
+++ b/vendor/core/src/core/html/include/sourcemeta/core/html.h
@@ -2,8 +2,8 @@
 #define SOURCEMETA_CORE_HTML_H_
 
 /// @defgroup html HTML
-/// @brief A growing implementation of HTML generation utilities per the HTML
-/// Living Standard.
+/// @brief A growing implementation of HTML utilities per the HTML Living
+/// Standard.
 ///
 /// This functionality is included as follows:
 ///
@@ -11,6 +11,7 @@
 /// #include <sourcemeta/core/html.h>
 /// ```
 
+#include <sourcemeta/core/html_entity.h>
 #include <sourcemeta/core/html_writer.h>
 
 #endif
diff --git a/vendor/core/src/core/html/include/sourcemeta/core/html_entity.h b/vendor/core/src/core/html/include/sourcemeta/core/html_entity.h
new file mode 100644
index 00000000..933f4ca5
--- /dev/null
+++ b/vendor/core/src/core/html/include/sourcemeta/core/html_entity.h
@@ -0,0 +1,34 @@
+#ifndef SOURCEMETA_CORE_HTML_ENTITY_H_
+#define SOURCEMETA_CORE_HTML_ENTITY_H_
+
+#ifndef SOURCEMETA_CORE_HTML_EXPORT
+#include <sourcemeta/core/html_export.h>
+#endif
+
+#include <string_view> // std::string_view
+
+namespace sourcemeta::core {
+
+/// @ingroup html
+/// Look up the characters of a named character reference per the HTML Living
+/// Standard, which lists every one of them at
+/// https://html.spec.whatwg.org/entities.json. The name excludes the leading
+/// ampersand and includes the trailing semicolon, which the standard lets a
+/// few legacy names omit. The result is the UTF-8 encoding of the characters,
+/// or an empty view if the name is not a named character reference.
+/// For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/html.h>
+/// #include <cassert>
+///
+/// assert(sourcemeta::core::html_entity("copy;") == "\xC2\xA9");
+/// assert(sourcemeta::core::html_entity("copy") == "\xC2\xA9");
+/// assert(sourcemeta::core::html_entity("ne").empty());
+/// ```
+SOURCEMETA_CORE_HTML_EXPORT
+auto html_entity(const std::string_view name) noexcept -> std::string_view;
+
+} // namespace sourcemeta::core
+
+#endif
diff --git a/vendor/core/src/core/jsonschema/helpers.h b/vendor/core/src/core/jsonschema/helpers.h
index ea15cfdc..253d3cbb 100644
--- a/vendor/core/src/core/jsonschema/helpers.h
+++ b/vendor/core/src/core/jsonschema/helpers.h
@@ -64,9 +64,6 @@ auto dialect(const sourcemeta::core::JSON &schema,
              std::string_view default_dialect = "",
              bool allow_dialect_override = true) -> std::string_view;
 
-auto vocabularies(const sourcemeta::core::JSON &schema,
-                  const SchemaResolver &resolver,
-                  std::string_view default_dialect = "") -> SchemaVocabularies;
 auto vocabularies(const SchemaResolver &resolver,
                   const SchemaBaseDialect base_dialect,
                   std::string_view dialect) -> SchemaVocabularies;
diff --git a/vendor/core/src/core/jsonschema/iterator.h b/vendor/core/src/core/jsonschema/iterator.h
index ed36ea0f..e568bdd5 100644
--- a/vendor/core/src/core/jsonschema/iterator.h
+++ b/vendor/core/src/core/jsonschema/iterator.h
@@ -476,8 +476,6 @@ class SchemaIterator {
                  std::string_view default_dialect = "");
   [[nodiscard]] auto begin() const -> const_iterator;
   [[nodiscard]] auto end() const -> const_iterator;
-  [[nodiscard]] auto cbegin() const -> const_iterator;
-  [[nodiscard]] auto cend() const -> const_iterator;
 
 private:
   internal subschemas_{};
@@ -523,12 +521,6 @@ inline auto SchemaIterator::begin() const -> const_iterator {
 inline auto SchemaIterator::end() const -> const_iterator {
   return this->subschemas_.end();
 }
-inline auto SchemaIterator::cbegin() const -> const_iterator {
-  return this->subschemas_.cbegin();
-}
-inline auto SchemaIterator::cend() const -> const_iterator {
-  return this->subschemas_.cend();
-}
 
 } // namespace sourcemeta::core
 
diff --git a/vendor/core/src/core/jsonschema/jsonschema.cc b/vendor/core/src/core/jsonschema/jsonschema.cc
index 28fea4a0..e0e6651c 100644
--- a/vendor/core/src/core/jsonschema/jsonschema.cc
+++ b/vendor/core/src/core/jsonschema/jsonschema.cc
@@ -614,42 +614,6 @@ auto parse_vocabularies(const sourcemeta::core::JSON &schema,
 }
 } // namespace
 
-auto sourcemeta::core::vocabularies(
-    const sourcemeta::core::JSON &schema,
-    const sourcemeta::core::SchemaResolver &resolver,
-    std::string_view default_dialect) -> sourcemeta::core::SchemaVocabularies {
-  const auto resolved_base_dialect{
-      sourcemeta::core::base_dialect(schema, resolver, default_dialect)};
-  if (!resolved_base_dialect.has_value()) {
-    throw sourcemeta::core::SchemaUnknownBaseDialectError();
-  }
-
-  const std::string_view resolved_dialect{
-      sourcemeta::core::dialect(schema, default_dialect)};
-  if (resolved_dialect.empty()) {
-    // If the schema has no declared metaschema and the user didn't
-    // provide a explicit default, then we cannot do anything.
-    // Better to abort instead of trying to guess.
-    throw sourcemeta::core::SchemaUnknownDialectError();
-  }
-
-  // A meta-schema that is embedded in the schema itself takes precedence
-  // over what the resolver knows about, as the schema pins the exact
-  // meta-schema it is described by
-  return vocabularies(
-      [&schema,
-       &resolver](const std::string_view identifier) -> SchemaResolverResult {
-        const auto *embedded{sourcemeta::core::metaschema_try_embedded(
-            schema, identifier, resolver)};
-        if (embedded) {
-          return *embedded;
-        }
-
-        return resolver(identifier);
-      },
-      resolved_base_dialect.value(), resolved_dialect);
-}
-
 auto sourcemeta::core::vocabularies(const SchemaResolver &resolver,
                                     const SchemaBaseDialect base_dialect,
                                     std::string_view dialect)
diff --git a/vendor/core/src/core/jsonschema/known_walker.cc b/vendor/core/src/core/jsonschema/known_walker.cc
index 947e0ba6..c35ec4ab 100644
--- a/vendor/core/src/core/jsonschema/known_walker.cc
+++ b/vendor/core/src/core/jsonschema/known_walker.cc
@@ -52,17 +52,6 @@ constexpr auto KEYWORDS_PROPERTIES_PATTERNPROPERTIES_ADDITIONALPROPERTIES{
 // One row per way a keyword can be recognised. The first row whose
 // vocabularies are all in play wins, so rows stay in priority order
 struct Variant {
-  constexpr Variant(
-      const Known required_vocabulary,
-      const std::optional<Known> secondary_vocabulary,
-      const SchemaKeywordType keyword_type,
-      const std::span<const std::string_view> keyword_dependencies,
-      const std::span<const std::string_view> keyword_order_dependencies,
-      const sourcemeta::core::JSON::TypeSet keyword_instances)
-      : vocabulary{required_vocabulary}, secondary{secondary_vocabulary},
-        result{keyword_type, required_vocabulary, keyword_dependencies,
-               keyword_order_dependencies, keyword_instances} {}
-
   // Both vocabularies must be in play for this row to match
   Known vocabulary;
   std::optional<Known> secondary;
@@ -70,4198 +59,4912 @@ struct Variant {
 };
 
 constexpr std::array<Variant, 700> VARIANTS{{
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Reference,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     Known::JSON_SCHEMA_2020_12_VALIDATION,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     KEYWORDS_MINCONTAINS_MAXCONTAINS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     Known::JSON_SCHEMA_2019_09_VALIDATION,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     KEYWORDS_MINCONTAINS_MAXCONTAINS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_CONTENT,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2019_09_CONTENT,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2020_12_CONTENT,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2019_09_CONTENT,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2020_12_CONTENT,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2019_09_CONTENT,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2020_12_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_CORE,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_CORE,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::LocationMembers,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersInPlaceSome,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSomeNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSomeNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_2_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_1_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_2_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_1_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_2_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_1_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_FORMAT_ASSERTION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2020_12_FORMAT_ANNOTATION,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2019_09_FORMAT,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_PREFIXITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlace,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_REAL},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_REAL},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_REAL},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_REAL},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_TYPE,
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_TYPE,
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_TYPE,
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_TYPE,
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_NUMBER},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceNegate,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_STRING},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsTraverseItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     Known::JSON_SCHEMA_2020_12_VALIDATION,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     KEYWORDS_REQUIRED,
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     Known::JSON_SCHEMA_2019_09_VALIDATION,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     KEYWORDS_REQUIRED,
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7, std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic, KEYWORDS_REF,
-     KEYWORDS_REQUIRED, INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER, std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic, KEYWORDS_REF,
-     KEYWORDS_REQUIRED, INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6, std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic, KEYWORDS_REF,
-     KEYWORDS_REQUIRED, INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER, std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic, KEYWORDS_REF,
-     KEYWORDS_REQUIRED, INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4, std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic, KEYWORDS_REF,
-     KEYWORDS_REQUIRED, INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER, std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic, KEYWORDS_REF,
-     KEYWORDS_REQUIRED, INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseParent,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseParent,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseParent,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseParent,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseParent,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseParent,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceOther,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueInPlaceMaybe,
-     KEYWORDS_IF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     KEYWORDS_PROPERTIES,
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_1_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_0_HYPER,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorElementsInPlaceSome,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2020_12_UNEVALUATED,
-     Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_PREFIXITEMS_ITEMS_CONTAINS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_UNEVALUATED,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeItem,
-     KEYWORDS_ITEMS_ADDITIONALITEMS,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_UNEVALUATED,
-     Known::JSON_SCHEMA_2020_12_APPLICATOR,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES_ADDITIONALPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_UNEVALUATED,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     {},
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2019_09_APPLICATOR,
-     std::nullopt,
-     SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
-     KEYWORDS_PROPERTIES_PATTERNPROPERTIES_ADDITIONALPROPERTIES,
-     {},
-     INSTANCES_OBJECT},
-    {Known::JSON_SCHEMA_2020_12_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2019_09_VALIDATION,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_4_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_3_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_DRAFT_2_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Assertion,
-     {},
-     {},
-     INSTANCES_ARRAY},
-    {Known::JSON_SCHEMA_2020_12_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_2019_09_META_DATA,
-     std::nullopt,
-     SchemaKeywordType::Annotation,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_7_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::JSON_SCHEMA_DRAFT_6_HYPER,
-     std::nullopt,
-     SchemaKeywordType::Comment,
-     KEYWORDS_REF,
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_2_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
-    {Known::OPENAPI_3_1_BASE,
-     std::nullopt,
-     SchemaKeywordType::Other,
-     {},
-     {},
-     INSTANCES_ANY},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_7,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_6,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_4,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_3,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Reference,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_ITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_2,
+                KEYWORDS_PROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                KEYWORDS_PROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_1,
+                KEYWORDS_PROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                KEYWORDS_PROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_0,
+                KEYWORDS_PROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                KEYWORDS_PROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                KEYWORDS_MINCONTAINS_MAXCONTAINS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                KEYWORDS_MINCONTAINS_MAXCONTAINS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyItem,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CONTENT,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_CONTENT,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CONTENT,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_CONTENT,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CONTENT,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_CONTENT,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CONTENT,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_CONTENT,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CONTENT,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_2020_12_CONTENT,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CONTENT,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_2019_09_CONTENT,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_2020_12_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_CORE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_2019_09_CORE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::LocationMembers,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersInPlaceSome,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSomeNegate,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSomeNegate,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_2_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_2_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_1_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_1_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_2_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_2_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_1_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_1_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueOrElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_2_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_2_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_1_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_1_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_FORMAT_ASSERTION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_FORMAT_ASSERTION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_FORMAT_ANNOTATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_FORMAT_ANNOTATION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_FORMAT,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_FORMAT,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                KEYWORDS_PREFIXITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_2019_09_APPLICATOR,
+          {},
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_7,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_7_HYPER,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_6,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_6_HYPER,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_4,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_4_HYPER,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_3,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_3_HYPER,
+          KEYWORDS_REF,
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_2,
+          {},
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_2_HYPER,
+          {},
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_1,
+          {},
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_1_HYPER,
+          {},
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_0,
+          {},
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result =
+         {SchemaKeywordType::ApplicatorValueOrElementsTraverseAnyItemOrItem,
+          Known::JSON_SCHEMA_DRAFT_0_HYPER,
+          {},
+          {},
+          INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlace,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_REAL}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_REAL}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_REAL}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_REAL}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                KEYWORDS_TYPE,
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                KEYWORDS_TYPE,
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                KEYWORDS_TYPE,
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                KEYWORDS_TYPE,
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_NUMBER}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceNegate,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_STRING}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyRegex,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsTraverseItem,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                KEYWORDS_REQUIRED,
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                KEYWORDS_REQUIRED,
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_7, KEYWORDS_REF, KEYWORDS_REQUIRED,
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER, KEYWORDS_REF,
+                KEYWORDS_REQUIRED, INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_6, KEYWORDS_REF, KEYWORDS_REQUIRED,
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER, KEYWORDS_REF,
+                KEYWORDS_REQUIRED, INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_4, KEYWORDS_REF, KEYWORDS_REQUIRED,
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER, KEYWORDS_REF,
+                KEYWORDS_REQUIRED, INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorMembersTraversePropertyStatic,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseAnyPropertyKey,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseParent,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseParent,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseParent,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseParent,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseParent,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseParent,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceOther,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_2019_09_HYPER_SCHEMA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_2020_12_APPLICATOR,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueInPlaceMaybe,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_IF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                {},
+                KEYWORDS_PROPERTIES,
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_1,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_1_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_1_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_0,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_0_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorElementsInPlaceSome,
+                Known::JSON_SCHEMA_DRAFT_0_HYPER,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+     .secondary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+                KEYWORDS_PREFIXITEMS_ITEMS_CONTAINS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeItem,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                KEYWORDS_ITEMS_ADDITIONALITEMS,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+     .secondary = Known::JSON_SCHEMA_2020_12_APPLICATOR,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES_ADDITIONALPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_2020_12_UNEVALUATED,
+                {},
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_APPLICATOR,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::ApplicatorValueTraverseSomeProperty,
+                Known::JSON_SCHEMA_2019_09_APPLICATOR,
+                KEYWORDS_PROPERTIES_PATTERNPROPERTIES_ADDITIONALPROPERTIES,
+                {},
+                INSTANCES_OBJECT}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2020_12_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_VALIDATION,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_2019_09_VALIDATION,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_4_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_4_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_3_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_3_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_2_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Assertion,
+                Known::JSON_SCHEMA_DRAFT_2_HYPER,
+                {},
+                {},
+                INSTANCES_ARRAY}},
+    {.vocabulary = Known::JSON_SCHEMA_2020_12_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2020_12_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_2019_09_META_DATA,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Annotation,
+                Known::JSON_SCHEMA_2019_09_META_DATA,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_7_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_7_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::JSON_SCHEMA_DRAFT_6_HYPER,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Comment,
+                Known::JSON_SCHEMA_DRAFT_6_HYPER,
+                KEYWORDS_REF,
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_2_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_2_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
+    {.vocabulary = Known::OPENAPI_3_1_BASE,
+     .secondary = std::nullopt,
+     .result = {SchemaKeywordType::Other,
+                Known::OPENAPI_3_1_BASE,
+                {},
+                {},
+                INSTANCES_ANY}},
 }};
 
 struct Keyword {
-  constexpr Keyword(const std::string_view keyword_name,
-                    const std::uint16_t variant_offset,
-                    const std::uint16_t variant_count,
-                    const bool has_legacy_ref)
-      : name{keyword_name}, offset{variant_offset}, count{variant_count},
-        legacy_ref{has_legacy_ref} {}
-
   std::string_view name;
   std::uint16_t offset;
   std::uint16_t count;
@@ -4271,108 +4974,144 @@ struct Keyword {
 };
 
 constexpr std::array<Keyword, 102> KEYWORDS{{
-    {"$anchor", 0, 2, false},
-    {"$comment", 2, 6, false},
-    {"$defs", 8, 2, false},
-    {"$dynamicAnchor", 10, 1, false},
-    {"$dynamicRef", 11, 1, false},
-    {"$id", 12, 6, false},
-    {"$recursiveAnchor", 18, 1, false},
-    {"$recursiveRef", 19, 1, false},
-    {"$ref", 20, 16, false},
-    {"$schema", 36, 16, false},
-    {"$vocabulary", 52, 2, false},
-    {"additionalItems", 54, 9, false},
-    {"additionalProperties", 63, 16, false},
-    {"allOf", 79, 8, false},
-    {"alternate", 87, 3, false},
-    {"anchor", 90, 2, true},
-    {"anchorPointer", 92, 2, true},
-    {"anyOf", 94, 8, false},
-    {"base", 102, 3, true},
-    {"const", 105, 6, false},
-    {"contains", 111, 8, false},
-    {"contentEncoding", 119, 13, true},
-    {"contentMediaType", 132, 6, false},
-    {"contentSchema", 138, 2, false},
-    {"default", 140, 16, false},
-    {"definitions", 156, 10, false},
-    {"dependencies", 166, 8, false},
-    {"dependentRequired", 174, 2, false},
-    {"dependentSchemas", 176, 2, false},
-    {"deprecated", 178, 2, false},
-    {"description", 180, 16, false},
-    {"disallow", 196, 8, false},
-    {"discriminator", 204, 2, false},
-    {"divisibleBy", 206, 4, false},
-    {"else", 210, 4, false},
-    {"encType", 214, 1, true},
-    {"enctype", 215, 4, true},
-    {"enum", 219, 16, false},
-    {"example", 235, 2, false},
-    {"examples", 237, 6, false},
-    {"exclusiveMaximum", 243, 10, false},
-    {"exclusiveMinimum", 253, 10, false},
-    {"extends", 263, 8, false},
-    {"externalDocs", 271, 2, false},
-    {"format", 273, 17, false},
-    {"fragmentResolution", 290, 5, true},
-    {"headerSchema", 295, 2, true},
-    {"href", 297, 8, true},
-    {"hrefSchema", 305, 3, true},
-    {"id", 308, 10, false},
-    {"if", 318, 4, false},
-    {"items", 322, 16, false},
-    {"links", 338, 8, true},
-    {"maxContains", 346, 2, false},
-    {"maxDecimal", 348, 4, false},
-    {"maxItems", 352, 16, false},
-    {"maxLength", 368, 16, false},
-    {"maxProperties", 384, 8, false},
-    {"maximum", 392, 16, false},
-    {"maximumCanEqual", 408, 6, false},
-    {"media", 414, 2, true},
-    {"mediaType", 416, 6, true},
-    {"method", 422, 5, true},
-    {"minContains", 427, 2, false},
-    {"minItems", 429, 16, false},
-    {"minLength", 445, 16, false},
-    {"minProperties", 461, 8, false},
-    {"minimum", 469, 16, false},
-    {"minimumCanEqual", 485, 6, false},
-    {"multipleOf", 491, 8, false},
-    {"not", 499, 8, false},
-    {"oneOf", 507, 8, false},
-    {"optional", 515, 6, false},
-    {"pathStart", 521, 5, true},
-    {"pattern", 526, 16, false},
-    {"patternProperties", 542, 10, false},
-    {"prefixItems", 552, 1, false},
-    {"properties", 553, 18, false},
-    {"propertyNames", 571, 6, false},
-    {"readOnly", 577, 6, true},
-    {"readonly", 583, 4, true},
-    {"rel", 587, 8, true},
-    {"required", 595, 10, false},
-    {"requires", 605, 6, false},
-    {"root", 611, 4, true},
-    {"schema", 615, 1, true},
-    {"submissionEncType", 616, 1, true},
-    {"submissionMediaType", 617, 2, true},
-    {"submissionSchema", 619, 3, true},
-    {"targetHints", 622, 2, true},
-    {"targetMediaType", 624, 2, true},
-    {"targetSchema", 626, 6, true},
-    {"templatePointers", 632, 2, true},
-    {"templateRequired", 634, 2, true},
-    {"then", 636, 4, false},
-    {"title", 640, 16, false},
-    {"type", 656, 18, false},
-    {"unevaluatedItems", 674, 3, false},
-    {"unevaluatedProperties", 677, 3, false},
-    {"uniqueItems", 680, 12, false},
-    {"writeOnly", 692, 6, false},
-    {"xml", 698, 2, false},
+    {.name = "$anchor", .offset = 0, .count = 2, .legacy_ref = false},
+    {.name = "$comment", .offset = 2, .count = 6, .legacy_ref = false},
+    {.name = "$defs", .offset = 8, .count = 2, .legacy_ref = false},
+    {.name = "$dynamicAnchor", .offset = 10, .count = 1, .legacy_ref = false},
+    {.name = "$dynamicRef", .offset = 11, .count = 1, .legacy_ref = false},
+    {.name = "$id", .offset = 12, .count = 6, .legacy_ref = false},
+    {.name = "$recursiveAnchor", .offset = 18, .count = 1, .legacy_ref = false},
+    {.name = "$recursiveRef", .offset = 19, .count = 1, .legacy_ref = false},
+    {.name = "$ref", .offset = 20, .count = 16, .legacy_ref = false},
+    {.name = "$schema", .offset = 36, .count = 16, .legacy_ref = false},
+    {.name = "$vocabulary", .offset = 52, .count = 2, .legacy_ref = false},
+    {.name = "additionalItems", .offset = 54, .count = 9, .legacy_ref = false},
+    {.name = "additionalProperties",
+     .offset = 63,
+     .count = 16,
+     .legacy_ref = false},
+    {.name = "allOf", .offset = 79, .count = 8, .legacy_ref = false},
+    {.name = "alternate", .offset = 87, .count = 3, .legacy_ref = false},
+    {.name = "anchor", .offset = 90, .count = 2, .legacy_ref = true},
+    {.name = "anchorPointer", .offset = 92, .count = 2, .legacy_ref = true},
+    {.name = "anyOf", .offset = 94, .count = 8, .legacy_ref = false},
+    {.name = "base", .offset = 102, .count = 3, .legacy_ref = true},
+    {.name = "const", .offset = 105, .count = 6, .legacy_ref = false},
+    {.name = "contains", .offset = 111, .count = 8, .legacy_ref = false},
+    {.name = "contentEncoding", .offset = 119, .count = 13, .legacy_ref = true},
+    {.name = "contentMediaType",
+     .offset = 132,
+     .count = 6,
+     .legacy_ref = false},
+    {.name = "contentSchema", .offset = 138, .count = 2, .legacy_ref = false},
+    {.name = "default", .offset = 140, .count = 16, .legacy_ref = false},
+    {.name = "definitions", .offset = 156, .count = 10, .legacy_ref = false},
+    {.name = "dependencies", .offset = 166, .count = 8, .legacy_ref = false},
+    {.name = "dependentRequired",
+     .offset = 174,
+     .count = 2,
+     .legacy_ref = false},
+    {.name = "dependentSchemas",
+     .offset = 176,
+     .count = 2,
+     .legacy_ref = false},
+    {.name = "deprecated", .offset = 178, .count = 2, .legacy_ref = false},
+    {.name = "description", .offset = 180, .count = 16, .legacy_ref = false},
+    {.name = "disallow", .offset = 196, .count = 8, .legacy_ref = false},
+    {.name = "discriminator", .offset = 204, .count = 2, .legacy_ref = false},
+    {.name = "divisibleBy", .offset = 206, .count = 4, .legacy_ref = false},
+    {.name = "else", .offset = 210, .count = 4, .legacy_ref = false},
+    {.name = "encType", .offset = 214, .count = 1, .legacy_ref = true},
+    {.name = "enctype", .offset = 215, .count = 4, .legacy_ref = true},
+    {.name = "enum", .offset = 219, .count = 16, .legacy_ref = false},
+    {.name = "example", .offset = 235, .count = 2, .legacy_ref = false},
+    {.name = "examples", .offset = 237, .count = 6, .legacy_ref = false},
+    {.name = "exclusiveMaximum",
+     .offset = 243,
+     .count = 10,
+     .legacy_ref = false},
+    {.name = "exclusiveMinimum",
+     .offset = 253,
+     .count = 10,
+     .legacy_ref = false},
+    {.name = "extends", .offset = 263, .count = 8, .legacy_ref = false},
+    {.name = "externalDocs", .offset = 271, .count = 2, .legacy_ref = false},
+    {.name = "format", .offset = 273, .count = 17, .legacy_ref = false},
+    {.name = "fragmentResolution",
+     .offset = 290,
+     .count = 5,
+     .legacy_ref = true},
+    {.name = "headerSchema", .offset = 295, .count = 2, .legacy_ref = true},
+    {.name = "href", .offset = 297, .count = 8, .legacy_ref = true},
+    {.name = "hrefSchema", .offset = 305, .count = 3, .legacy_ref = true},
+    {.name = "id", .offset = 308, .count = 10, .legacy_ref = false},
+    {.name = "if", .offset = 318, .count = 4, .legacy_ref = false},
+    {.name = "items", .offset = 322, .count = 16, .legacy_ref = false},
+    {.name = "links", .offset = 338, .count = 8, .legacy_ref = true},
+    {.name = "maxContains", .offset = 346, .count = 2, .legacy_ref = false},
+    {.name = "maxDecimal", .offset = 348, .count = 4, .legacy_ref = false},
+    {.name = "maxItems", .offset = 352, .count = 16, .legacy_ref = false},
+    {.name = "maxLength", .offset = 368, .count = 16, .legacy_ref = false},
+    {.name = "maxProperties", .offset = 384, .count = 8, .legacy_ref = false},
+    {.name = "maximum", .offset = 392, .count = 16, .legacy_ref = false},
+    {.name = "maximumCanEqual", .offset = 408, .count = 6, .legacy_ref = false},
+    {.name = "media", .offset = 414, .count = 2, .legacy_ref = true},
+    {.name = "mediaType", .offset = 416, .count = 6, .legacy_ref = true},
+    {.name = "method", .offset = 422, .count = 5, .legacy_ref = true},
+    {.name = "minContains", .offset = 427, .count = 2, .legacy_ref = false},
+    {.name = "minItems", .offset = 429, .count = 16, .legacy_ref = false},
+    {.name = "minLength", .offset = 445, .count = 16, .legacy_ref = false},
+    {.name = "minProperties", .offset = 461, .count = 8, .legacy_ref = false},
+    {.name = "minimum", .offset = 469, .count = 16, .legacy_ref = false},
+    {.name = "minimumCanEqual", .offset = 485, .count = 6, .legacy_ref = false},
+    {.name = "multipleOf", .offset = 491, .count = 8, .legacy_ref = false},
+    {.name = "not", .offset = 499, .count = 8, .legacy_ref = false},
+    {.name = "oneOf", .offset = 507, .count = 8, .legacy_ref = false},
+    {.name = "optional", .offset = 515, .count = 6, .legacy_ref = false},
+    {.name = "pathStart", .offset = 521, .count = 5, .legacy_ref = true},
+    {.name = "pattern", .offset = 526, .count = 16, .legacy_ref = false},
+    {.name = "patternProperties",
+     .offset = 542,
+     .count = 10,
+     .legacy_ref = false},
+    {.name = "prefixItems", .offset = 552, .count = 1, .legacy_ref = false},
+    {.name = "properties", .offset = 553, .count = 18, .legacy_ref = false},
+    {.name = "propertyNames", .offset = 571, .count = 6, .legacy_ref = false},
+    {.name = "readOnly", .offset = 577, .count = 6, .legacy_ref = true},
+    {.name = "readonly", .offset = 583, .count = 4, .legacy_ref = true},
+    {.name = "rel", .offset = 587, .count = 8, .legacy_ref = true},
+    {.name = "required", .offset = 595, .count = 10, .legacy_ref = false},
+    {.name = "requires", .offset = 605, .count = 6, .legacy_ref = false},
+    {.name = "root", .offset = 611, .count = 4, .legacy_ref = true},
+    {.name = "schema", .offset = 615, .count = 1, .legacy_ref = true},
+    {.name = "submissionEncType",
+     .offset = 616,
+     .count = 1,
+     .legacy_ref = true},
+    {.name = "submissionMediaType",
+     .offset = 617,
+     .count = 2,
+     .legacy_ref = true},
+    {.name = "submissionSchema", .offset = 619, .count = 3, .legacy_ref = true},
+    {.name = "targetHints", .offset = 622, .count = 2, .legacy_ref = true},
+    {.name = "targetMediaType", .offset = 624, .count = 2, .legacy_ref = true},
+    {.name = "targetSchema", .offset = 626, .count = 6, .legacy_ref = true},
+    {.name = "templatePointers", .offset = 632, .count = 2, .legacy_ref = true},
+    {.name = "templateRequired", .offset = 634, .count = 2, .legacy_ref = true},
+    {.name = "then", .offset = 636, .count = 4, .legacy_ref = false},
+    {.name = "title", .offset = 640, .count = 16, .legacy_ref = false},
+    {.name = "type", .offset = 656, .count = 18, .legacy_ref = false},
+    {.name = "unevaluatedItems",
+     .offset = 674,
+     .count = 3,
+     .legacy_ref = false},
+    {.name = "unevaluatedProperties",
+     .offset = 677,
+     .count = 3,
+     .legacy_ref = false},
+    {.name = "uniqueItems", .offset = 680, .count = 12, .legacy_ref = false},
+    {.name = "writeOnly", .offset = 692, .count = 6, .legacy_ref = false},
+    {.name = "xml", .offset = 698, .count = 2, .legacy_ref = false},
 }};
 
 constexpr auto REF_DEPENDENCIES{std::to_array<std::string_view>({"$ref"})};
diff --git a/vendor/core/src/core/markdown/CMakeLists.txt b/vendor/core/src/core/markdown/CMakeLists.txt
index be72c09d..048612f0 100644
--- a/vendor/core/src/core/markdown/CMakeLists.txt
+++ b/vendor/core/src/core/markdown/CMakeLists.txt
@@ -6,3 +6,6 @@ if(SOURCEMETA_CORE_INSTALL)
 endif()
 
 target_link_libraries(sourcemeta_core_markdown PRIVATE CMarkGFM::cmark_gfm)
+
+target_link_libraries(sourcemeta_core_markdown PRIVATE
+  sourcemeta::core::unicode)
diff --git a/vendor/core/src/core/markdown/markdown.cc b/vendor/core/src/core/markdown/markdown.cc
index 367dc2d8..a35ffc59 100644
--- a/vendor/core/src/core/markdown/markdown.cc
+++ b/vendor/core/src/core/markdown/markdown.cc
@@ -1,13 +1,16 @@
 #include <sourcemeta/core/markdown.h>
+#include <sourcemeta/core/unicode.h>
 
 #include <cmark-gfm-core-extensions.h> // cmark_gfm_core_extensions_ensure_registered
 #include <cmark-gfm-extension_api.h> // cmark_find_syntax_extension, cmark_parser_attach_syntax_extension, cmark_parser_get_syntax_extensions
 #include <cmark-gfm.h> // cmark_parser_new, cmark_parser_feed, cmark_parser_finish, cmark_parser_free, cmark_render_html, cmark_node_free
 
-#include <array>   // std::array
-#include <cstdlib> // std::free
-#include <mutex>   // std::mutex, std::scoped_lock
-#include <string>  // std::string
+#include <array>       // std::array
+#include <cstddef>     // std::size_t
+#include <cstdlib>     // std::free
+#include <mutex>       // std::mutex, std::scoped_lock
+#include <string>      // std::string
+#include <string_view> // std::string_view
 
 namespace sourcemeta::core {
 
@@ -16,6 +19,23 @@ auto markdown_to_html(const std::string_view input, const bool safe)
   [[maybe_unused]] static const bool CMARK_INITIALIZED{
       (cmark_gfm_core_extensions_ensure_registered(), true)};
 
+  // Byte sequences that are not UTF-8 become one replacement character per
+  // maximal subpart, as the Unicode Standard recommends, rather than the one
+  // replacement character per sequence that the parser would produce
+  std::size_t valid_length{0};
+  while (valid_length < input.size()) {
+    const auto length{utf8_codepoint_length(input, valid_length)};
+    if (length == 0) {
+      break;
+    }
+
+    valid_length += length;
+  }
+
+  const auto is_valid{valid_length == input.size()};
+  const auto repaired{is_valid ? std::string{} : to_valid_utf8(input)};
+  const std::string_view source{is_valid ? input : std::string_view{repaired}};
+
   // cmark-gfm toggles process-global special-character tables when syntax
   // extensions are attached and detached, so parser construction through
   // teardown cannot run concurrently
@@ -40,7 +60,7 @@ auto markdown_to_html(const std::string_view input, const bool safe)
     }
   }
 
-  cmark_parser_feed(parser, input.data(), input.size());
+  cmark_parser_feed(parser, source.data(), source.size());
   auto *document{cmark_parser_finish(parser)};
   auto *result{cmark_render_html(document, options,
                                  cmark_parser_get_syntax_extensions(parser))};
diff --git a/vendor/core/src/core/oidc/oidc_userinfo.cc b/vendor/core/src/core/oidc/oidc_userinfo.cc
index 0929975b..87f88975 100644
--- a/vendor/core/src/core/oidc/oidc_userinfo.cc
+++ b/vendor/core/src/core/oidc/oidc_userinfo.cc
@@ -21,17 +21,23 @@ struct Claim {
   sourcemeta::core::JSON::Object::hash_type hash;
 };
 
-constexpr auto to_claim(const sourcemeta::core::JSON::StringView name) noexcept
-    -> Claim {
-  return {.name = name, .hash = sourcemeta::core::JSON::Object::hash(name)};
-}
-
-constexpr auto CLAIM_EMAIL{to_claim("email"sv)};
-constexpr auto CLAIM_EMAIL_VERIFIED{to_claim("email_verified"sv)};
-constexpr auto CLAIM_PHONE_NUMBER{to_claim("phone_number"sv)};
-constexpr auto CLAIM_PHONE_NUMBER_VERIFIED{to_claim("phone_number_verified"sv)};
-constexpr auto CLAIM_NAMES{to_claim("_claim_names"sv)};
-constexpr auto CLAIM_SOURCES{to_claim("_claim_sources"sv)};
+constexpr Claim CLAIM_EMAIL{
+    .name = "email"sv, .hash = sourcemeta::core::JSON::Object::hash("email"sv)};
+constexpr Claim CLAIM_EMAIL_VERIFIED{
+    .name = "email_verified"sv,
+    .hash = sourcemeta::core::JSON::Object::hash("email_verified"sv)};
+constexpr Claim CLAIM_PHONE_NUMBER{
+    .name = "phone_number"sv,
+    .hash = sourcemeta::core::JSON::Object::hash("phone_number"sv)};
+constexpr Claim CLAIM_PHONE_NUMBER_VERIFIED{
+    .name = "phone_number_verified"sv,
+    .hash = sourcemeta::core::JSON::Object::hash("phone_number_verified"sv)};
+constexpr Claim CLAIM_NAMES{
+    .name = "_claim_names"sv,
+    .hash = sourcemeta::core::JSON::Object::hash("_claim_names"sv)};
+constexpr Claim CLAIM_SOURCES{
+    .name = "_claim_sources"sv,
+    .hash = sourcemeta::core::JSON::Object::hash("_claim_sources"sv)};
 
 // A claim delivers nothing when it is absent, null, or an empty string, which
 // are the shapes OpenID Connect Core 1.0 Section 5.3.2 names in having an
diff --git a/vendor/core/src/core/openapi/helpers.h b/vendor/core/src/core/openapi/helpers.h
index 5dc7469d..c3de0623 100644
--- a/vendor/core/src/core/openapi/helpers.h
+++ b/vendor/core/src/core/openapi/helpers.h
@@ -41,11 +41,6 @@ struct OpenAPIField {
   JSON::Object::hash_type hash;
 };
 
-constexpr auto openapi_field(const JSON::StringView name) noexcept
-    -> OpenAPIField {
-  return {.name = name, .hash = JSON::Object::hash(name)};
-}
-
 // What a reference expects to find at the far end of itself, which is fixed by
 // where the reference sits rather than by anything the target says about
 // itself. OpenAPI Specification 3.1.1, Section 4.3.1 calls this "the expected
diff --git a/vendor/core/src/core/openapi/path_item.h b/vendor/core/src/core/openapi/path_item.h
index eb738d19..e3fdf76c 100644
--- a/vendor/core/src/core/openapi/path_item.h
+++ b/vendor/core/src/core/openapi/path_item.h
@@ -43,10 +43,15 @@ constexpr std::array<JSON::StringView, 15> OPENAPI_PATH_ITEM_FIELDS_3_2{
 // RFC 10008. Looping over all nine under either revision is safe because the
 // field table above has already turned down a `query` in a 3.1 document
 constexpr std::array<OpenAPIField, 9> OPENAPI_PATH_ITEM_METHODS{
-    {openapi_field("get"sv), openapi_field("put"sv), openapi_field("post"sv),
-     openapi_field("delete"sv), openapi_field("options"sv),
-     openapi_field("head"sv), openapi_field("patch"sv),
-     openapi_field("trace"sv), openapi_field("query"sv)}};
+    {{.name = "get"sv, .hash = JSON::Object::hash("get"sv)},
+     {.name = "put"sv, .hash = JSON::Object::hash("put"sv)},
+     {.name = "post"sv, .hash = JSON::Object::hash("post"sv)},
+     {.name = "delete"sv, .hash = JSON::Object::hash("delete"sv)},
+     {.name = "options"sv, .hash = JSON::Object::hash("options"sv)},
+     {.name = "head"sv, .hash = JSON::Object::hash("head"sv)},
+     {.name = "patch"sv, .hash = JSON::Object::hash("patch"sv)},
+     {.name = "trace"sv, .hash = JSON::Object::hash("trace"sv)},
+     {.name = "query"sv, .hash = JSON::Object::hash("query"sv)}}};
 
 // The methods those nine fields define, which the same section spells in
 // uppercase in each of their descriptions, and which an `additionalOperations`
diff --git a/vendor/core/src/core/regex/permissive.h b/vendor/core/src/core/regex/permissive.h
index 4b395298..2b3cbee0 100644
--- a/vendor/core/src/core/regex/permissive.h
+++ b/vendor/core/src/core/regex/permissive.h
@@ -99,56 +99,16 @@ inline auto parse_hex_digits(const std::string &content, std::size_t start,
   return value;
 }
 
-constexpr auto make_digit_class() -> std::bitset<128> {
-  std::bitset<128> result;
-  for (int code = '0'; code <= '9'; ++code) {
-    result.set(static_cast<std::size_t>(code));
-  }
-
-  return result;
-}
-
-constexpr auto make_word_class() -> std::bitset<128> {
-  std::bitset<128> result;
-  for (int code = 'a'; code <= 'z'; ++code) {
-    result.set(static_cast<std::size_t>(code));
-  }
-
-  for (int code = 'A'; code <= 'Z'; ++code) {
-    result.set(static_cast<std::size_t>(code));
-  }
-
-  for (int code = '0'; code <= '9'; ++code) {
-    result.set(static_cast<std::size_t>(code));
-  }
-
-  result.set('_');
-  return result;
-}
-
-constexpr auto make_space_class() -> std::bitset<128> {
-  std::bitset<128> result;
-  result.set(' ');
-  result.set('\t');
-  result.set('\n');
-  result.set('\r');
-  result.set('\f');
-  result.set('\v');
-  return result;
-}
-
-constexpr auto negate_class(const std::bitset<128> &base) -> std::bitset<128> {
-  auto result = ~base;
-  result.reset(0);
-  return result;
-}
-
-constexpr auto DIGIT_CLASS = make_digit_class();
-constexpr auto WORD_CLASS = make_word_class();
-constexpr auto SPACE_CLASS = make_space_class();
-constexpr auto NON_DIGIT_CLASS = negate_class(DIGIT_CLASS);
-constexpr auto NON_WORD_CLASS = negate_class(WORD_CLASS);
-constexpr auto NON_SPACE_CLASS = negate_class(SPACE_CLASS);
+// The ASCII members of each shorthand class as a set of code points, spelled
+// as the high and low halves of the set. The negated classes leave out the NUL
+// code point along with the members
+constexpr auto DIGIT_CLASS{std::bitset<128>{0x03FF000000000000ULL}};
+constexpr auto WORD_CLASS{(std::bitset<128>{0x07FFFFFE87FFFFFEULL} << 64U) |
+                          std::bitset<128>{0x03FF000000000000ULL}};
+constexpr auto SPACE_CLASS{std::bitset<128>{0x0000000100003E00ULL}};
+constexpr auto NON_DIGIT_CLASS{(~DIGIT_CLASS).reset(0)};
+constexpr auto NON_WORD_CLASS{(~WORD_CLASS).reset(0)};
+constexpr auto NON_SPACE_CLASS{(~SPACE_CLASS).reset(0)};
 
 inline auto set_shorthand_class(std::bitset<128> &characters,
                                 const char shorthand) -> void {
diff --git a/vendor/core/src/core/terminal/include/sourcemeta/core/terminal.h b/vendor/core/src/core/terminal/include/sourcemeta/core/terminal.h
index fbbe84a7..527d28c0 100644
--- a/vendor/core/src/core/terminal/include/sourcemeta/core/terminal.h
+++ b/vendor/core/src/core/terminal/include/sourcemeta/core/terminal.h
@@ -76,7 +76,10 @@ enum class TerminalColorPolicy : std::uint8_t {
   /// https://pubs.opengroup.org/onlinepubs/9699919799/functions/isatty.html
   WhenInteractive,
   /// Styling is unconditionally suppressed.
-  Disabled
+  Disabled,
+  /// Styling is unconditionally enabled regardless of destination
+  /// interactivity.
+  Always
 };
 
 /// @ingroup terminal
@@ -328,6 +331,49 @@ SOURCEMETA_CORE_TERMINAL_EXPORT
 auto terminal_set_color_policy(TerminalStream stream,
                                TerminalColorPolicy policy) noexcept -> void;
 
+/// @ingroup terminal
+///
+/// Reset the color policy across all streams to default
+/// (`TerminalColorPolicy::WhenInteractive`).
+///
+/// For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/terminal.h>
+/// #include <cassert>
+///
+/// sourcemeta::core::terminal_set_color_policy(
+///     sourcemeta::core::TerminalColorPolicy::Disabled);
+/// sourcemeta::core::terminal_reset_color_policy();
+/// assert(sourcemeta::core::terminal_color_policy() ==
+///        sourcemeta::core::TerminalColorPolicy::WhenInteractive);
+/// ```
+SOURCEMETA_CORE_TERMINAL_EXPORT
+auto terminal_reset_color_policy() noexcept -> void;
+
+/// @ingroup terminal
+///
+/// Reset the color policy for a specific stream to default
+/// (`TerminalColorPolicy::WhenInteractive`).
+///
+/// For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/terminal.h>
+/// #include <cassert>
+///
+/// sourcemeta::core::terminal_set_color_policy(
+///     sourcemeta::core::TerminalStream::Stderr,
+///     sourcemeta::core::TerminalColorPolicy::Disabled);
+/// sourcemeta::core::terminal_reset_color_policy(
+///     sourcemeta::core::TerminalStream::Stderr);
+/// assert(sourcemeta::core::terminal_color_policy(
+///            sourcemeta::core::TerminalStream::Stderr) ==
+///        sourcemeta::core::TerminalColorPolicy::WhenInteractive);
+/// ```
+SOURCEMETA_CORE_TERMINAL_EXPORT
+auto terminal_reset_color_policy(TerminalStream stream) noexcept -> void;
+
 /// @ingroup terminal
 ///
 /// Retrieve the current color policy for the specified stream.
@@ -340,7 +386,8 @@ auto terminal_set_color_policy(TerminalStream stream,
 ///
 /// const auto policy{sourcemeta::core::terminal_color_policy()};
 /// assert(policy == sourcemeta::core::TerminalColorPolicy::WhenInteractive ||
-///        policy == sourcemeta::core::TerminalColorPolicy::Disabled);
+///        policy == sourcemeta::core::TerminalColorPolicy::Disabled ||
+///        policy == sourcemeta::core::TerminalColorPolicy::Always);
 /// ```
 SOURCEMETA_CORE_TERMINAL_EXPORT
 auto terminal_color_policy(
diff --git a/vendor/core/src/core/terminal/terminal.cc b/vendor/core/src/core/terminal/terminal.cc
index 82992ced..2029dfbf 100644
--- a/vendor/core/src/core/terminal/terminal.cc
+++ b/vendor/core/src/core/terminal/terminal.cc
@@ -10,7 +10,7 @@
 #include <ostream>     // std::ostream
 #include <string>      // std::string
 #include <string_view> // std::string_view
-#include <utility>     // std::to_underlying
+#include <utility>     // std::to_underlying, std::unreachable
 
 namespace {
 
@@ -49,14 +49,30 @@ auto terminal_set_color_policy(TerminalStream stream,
                                               std::memory_order_relaxed);
 }
 
+auto terminal_reset_color_policy() noexcept -> void {
+  terminal_set_color_policy(TerminalColorPolicy::WhenInteractive);
+}
+
+auto terminal_reset_color_policy(TerminalStream stream) noexcept -> void {
+  terminal_set_color_policy(stream, TerminalColorPolicy::WhenInteractive);
+}
+
 auto terminal_color_policy(TerminalStream stream) noexcept
     -> TerminalColorPolicy {
   return stream_policies[stream_index(stream)].load(std::memory_order_relaxed);
 }
 
 auto terminal_color_enabled(TerminalStream stream) noexcept -> bool {
-  return terminal_color_policy(stream) != TerminalColorPolicy::Disabled &&
-         terminal_is_interactive(stream);
+  switch (terminal_color_policy(stream)) {
+    case TerminalColorPolicy::WhenInteractive:
+      return terminal_is_interactive(stream);
+    case TerminalColorPolicy::Always:
+      return true;
+    case TerminalColorPolicy::Disabled:
+      return false;
+    default:
+      std::unreachable();
+  }
 }
 
 auto terminal_sgr_reset() noexcept -> std::string_view {
@@ -122,9 +138,11 @@ auto terminal_paint(TerminalStream stream, std::string_view text,
   assert(terminal_style_is_valid(style));
 
   const bool enabled{terminal_color_enabled(stream)};
+#if defined(_WIN32)
   if (enabled && style != TerminalStyle::None && !text.empty()) {
     internal::enable_virtual_terminal_stream(stream);
   }
+#endif
   return terminal_paint(text, style, enabled);
 }
 
@@ -153,9 +171,11 @@ auto terminal_paint(std::ostream &output, TerminalStream stream,
   assert(terminal_style_is_valid(style));
 
   const bool enabled{terminal_color_enabled(stream)};
+#if defined(_WIN32)
   if (enabled && style != TerminalStyle::None && !text.empty()) {
     internal::enable_virtual_terminal_stream(stream);
   }
+#endif
   return terminal_paint(output, text, style, enabled);
 }
 
diff --git a/vendor/core/src/core/terminal/terminal_internal.h b/vendor/core/src/core/terminal/terminal_internal.h
index 56024fb7..fb2c93f8 100644
--- a/vendor/core/src/core/terminal/terminal_internal.h
+++ b/vendor/core/src/core/terminal/terminal_internal.h
@@ -7,7 +7,11 @@ namespace sourcemeta::core::internal {
 
 auto is_interactive_stream(TerminalStream stream) noexcept -> bool;
 auto is_interactive_fd(int file_descriptor) noexcept -> bool;
+// POSIX terminals interpret ANSI escape sequences natively, so only Windows has
+// anything to enable
+#if defined(_WIN32)
 auto enable_virtual_terminal_stream(TerminalStream stream) noexcept -> void;
+#endif
 
 } // namespace sourcemeta::core::internal
 
diff --git a/vendor/core/src/core/terminal/terminal_posix.cc b/vendor/core/src/core/terminal/terminal_posix.cc
index 9cea107f..d1152c8e 100644
--- a/vendor/core/src/core/terminal/terminal_posix.cc
+++ b/vendor/core/src/core/terminal/terminal_posix.cc
@@ -19,8 +19,4 @@ auto is_interactive_fd(int file_descriptor) noexcept -> bool {
   return ::isatty(file_descriptor) == 1;
 }
 
-auto enable_virtual_terminal_stream(TerminalStream) noexcept -> void {
-  // POSIX terminals interpret ANSI escape sequences natively.
-}
-
 } // namespace sourcemeta::core::internal
diff --git a/vendor/core/src/core/unicode/CMakeLists.txt b/vendor/core/src/core/unicode/CMakeLists.txt
index c5d42a16..696173f6 100644
--- a/vendor/core/src/core/unicode/CMakeLists.txt
+++ b/vendor/core/src/core/unicode/CMakeLists.txt
@@ -27,6 +27,7 @@ add_custom_command(
     "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/UnicodeData.txt"
     "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/CompositionExclusions.txt"
     "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/DerivedCoreProperties.txt"
+    "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/CaseFolding.txt"
   DEPENDS
     "${SOURCEMETA_CORE_UNICODE_CODEGEN_TARGET}"
     "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/PropertyValueAliases.txt"
@@ -39,6 +40,7 @@ add_custom_command(
     "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/UnicodeData.txt"
     "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/CompositionExclusions.txt"
     "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/DerivedCoreProperties.txt"
+    "${SOURCEMETA_CORE_UNICODE_UCD_DIR}/CaseFolding.txt"
   COMMENT "Generating Unicode property tables"
   VERBATIM)
 
diff --git a/vendor/core/src/core/unicode/codegen.cc b/vendor/core/src/core/unicode/codegen.cc
index 86e4b2ad..f249118b 100644
--- a/vendor/core/src/core/unicode/codegen.cc
+++ b/vendor/core/src/core/unicode/codegen.cc
@@ -5,7 +5,7 @@
 #include <sourcemeta/core/options.h>
 #include <sourcemeta/core/text.h>
 
-#include <algorithm> // std::sort
+#include <algorithm> // std::ranges::sort, std::ranges::find
 #include <array>     // std::array
 #include <cstddef>   // std::size_t, std::ptrdiff_t
 #include <cstdint> // std::uint8_t, std::uint16_t, std::uint32_t, std::uint64_t
@@ -15,7 +15,7 @@
 #include <ios>         // std::hex, std::uppercase, std::dec
 #include <iostream>    // std::cerr
 #include <map>         // std::map
-#include <optional>    // std::optional
+#include <optional>    // std::optional, std::nullopt
 #include <ostream>     // std::ostream
 #include <ranges>      // std::views::transform
 #include <regex>       // std::regex, std::regex_match, std::smatch, std::cmatch
@@ -34,9 +34,10 @@ constexpr std::size_t TOTAL_CODEPOINTS{0x110000};
 constexpr std::size_t TABLE_PAGE_SHIFT{10};
 constexpr std::size_t TABLE_PAGE_SIZE{1 << TABLE_PAGE_SHIFT};
 constexpr std::size_t NUM_PAGES{TOTAL_CODEPOINTS / TABLE_PAGE_SIZE};
-constexpr std::size_t DECOMPOSITION_OFFSET_BITS{14};
-constexpr std::size_t DECOMPOSITION_OFFSET_MASK{
-    (1U << DECOMPOSITION_OFFSET_BITS) - 1U};
+constexpr std::size_t MAPPING_OFFSET_BITS{14};
+constexpr std::size_t MAPPING_OFFSET_MASK{(1U << MAPPING_OFFSET_BITS) - 1U};
+constexpr std::size_t MAPPING_LENGTH_MAXIMUM{
+    (1U << (16U - MAPPING_OFFSET_BITS)) - 1U};
 
 constexpr auto JOINING_TYPE_ORDER{std::to_array<std::string_view>({
 #define SOURCEMETA_CORE_UCD_ALIAS_ENTRY(name, alias) alias,
@@ -62,6 +63,17 @@ constexpr auto UNICODE_SCRIPT_ORDER{std::to_array<std::string_view>({
 #undef SOURCEMETA_CORE_UCD_ALIAS_ENTRY
 })};
 
+constexpr auto GENERAL_CATEGORY_ORDER{std::to_array<std::string_view>({
+#define SOURCEMETA_CORE_UCD_ALIAS_ENTRY(name, alias) alias,
+    SOURCEMETA_CORE_GENERAL_CATEGORY_LIST(SOURCEMETA_CORE_UCD_ALIAS_ENTRY)
+#undef SOURCEMETA_CORE_UCD_ALIAS_ENTRY
+})};
+
+// Per UAX #44, these general category values only group other values together
+// and never describe a codepoint on their own
+constexpr auto GENERAL_CATEGORY_GROUPS{
+    std::to_array<std::string_view>({"LC", "L", "M", "N", "P", "S", "Z", "C"})};
+
 using ValueMap = std::map<std::string, std::uint8_t, std::less<>>;
 
 struct PropertyEntry {
@@ -75,7 +87,7 @@ struct TwoStageTable {
   std::vector<std::uint8_t> stage2;
 };
 
-struct DecompositionTable {
+struct MappingTable {
   std::vector<char32_t> blob;
   std::vector<std::uint16_t> stage1;
   std::vector<std::uint16_t> stage2;
@@ -115,6 +127,15 @@ auto canonical_index(const std::span<const std::string_view> order,
   throw std::runtime_error{"Alias not in canonical order"};
 }
 
+auto general_category_index(const std::span<const std::string_view> aliases)
+    -> std::optional<std::uint8_t> {
+  if (std::ranges::find(GENERAL_CATEGORY_GROUPS, aliases.front()) !=
+      GENERAL_CATEGORY_GROUPS.end()) {
+    return std::nullopt;
+  }
+  return canonical_index(GENERAL_CATEGORY_ORDER, aliases);
+}
+
 template <typename Callback>
 auto for_each_ucd_entry(std::istream &stream, Callback callback) -> void {
   static const std::regex LINE_RE{
@@ -157,11 +178,21 @@ auto for_each_ucd_entry(std::istream &stream, Callback callback) -> void {
 
 auto parse_property_file(const std::filesystem::path &input_path,
                          const ValueMap &value_map,
-                         const std::optional<std::string_view> property_filter)
+                         const std::optional<std::string_view> property_filter,
+                         const std::optional<std::string_view> default_value)
     -> std::vector<PropertyEntry> {
   auto stream{sourcemeta::core::read_file(input_path)};
   std::vector<PropertyEntry> missing;
   std::vector<PropertyEntry> data;
+  if (default_value.has_value()) {
+    const auto default_iterator{value_map.find(default_value.value())};
+    if (default_iterator == value_map.end()) {
+      throw std::runtime_error{std::string{"Unknown property value: "}.append(
+          default_value.value())};
+    }
+    missing.push_back(
+        {.first = 0, .last = 0x10FFFF, .value = default_iterator->second});
+  }
   for_each_ucd_entry(stream, [&](const UCDEntry &entry) {
     std::string_view value_token;
     if (property_filter.has_value()) {
@@ -258,9 +289,12 @@ auto build_alias_map(const std::filesystem::path &aliases_path,
     }
     const std::span<const std::string_view> aliases{fields.begin() + 1,
                                                     fields.end()};
-    const auto value{value_fn(aliases)};
+    const std::optional<std::uint8_t> value{value_fn(aliases)};
+    if (!value.has_value()) {
+      return;
+    }
     for (const auto alias : aliases) {
-      result[std::string{alias}] = value;
+      result[std::string{alias}] = value.value();
     }
   });
   return result;
@@ -325,6 +359,61 @@ auto parse_unicode_data(const std::filesystem::path &input_path)
   return result;
 }
 
+auto parse_case_folding(const std::filesystem::path &input_path)
+    -> std::map<std::uint32_t, std::vector<std::uint32_t>> {
+  auto stream{sourcemeta::core::read_file(input_path)};
+  std::map<std::uint32_t, std::vector<std::uint32_t>> result;
+  for_each_ucd_entry(stream, [&](const UCDEntry &entry) {
+    if (entry.first != entry.last) {
+      throw std::runtime_error{
+          "CaseFolding.txt: codepoint range not supported"};
+    }
+    std::array<std::string_view, 2> rest{};
+    std::size_t count{0};
+    sourcemeta::core::split(entry.trailing, ';',
+                            [&](const std::string_view field) {
+                              if (count < rest.size()) {
+                                rest[count] = field;
+                              }
+                              count += 1;
+                            });
+    if (count < rest.size()) {
+      throw std::runtime_error{
+          std::string{"CaseFolding.txt: too few fields in line: "}.append(
+              entry.trailing)};
+    }
+    // Full case folding takes the common and full mappings, leaving out the
+    // simple ones and the Turkic ones
+    const auto status{sourcemeta::core::trim(rest[0])};
+    if (status == "S" || status == "T") {
+      return;
+    }
+    if (status != "C" && status != "F") {
+      throw std::runtime_error{
+          std::string{"CaseFolding.txt: unknown status: "}.append(status)};
+    }
+    std::vector<std::uint32_t> folding;
+    sourcemeta::core::split(sourcemeta::core::trim(rest[1]), ' ',
+                            [&](const std::string_view token) {
+                              const auto trimmed{sourcemeta::core::trim(token)};
+                              if (!trimmed.empty()) {
+                                folding.push_back(parse_hex_codepoint(trimmed));
+                              }
+                            });
+    if (folding.empty()) {
+      throw std::runtime_error{
+          std::string{"CaseFolding.txt: empty mapping in line: "}.append(
+              entry.trailing)};
+    }
+    if (!result.emplace(entry.first, std::move(folding)).second) {
+      throw std::runtime_error{
+          std::string{"CaseFolding.txt: more than one full case folding for "
+                      "a codepoint"}};
+    }
+  });
+  return result;
+}
+
 auto build_canonical_compositions(
     const std::map<std::uint32_t, std::vector<std::uint32_t>> &decompositions,
     const std::unordered_map<std::uint32_t, std::uint8_t> &ccc,
@@ -389,22 +478,24 @@ auto build_page_table(const std::span<const T> values)
   return {std::move(stage1), std::move(stage2)};
 }
 
-auto build_canonical_decomposition_pages(
-    const std::map<std::uint32_t, std::vector<std::uint32_t>> &decompositions)
-    -> DecompositionTable {
+auto build_mapping_pages(
+    const std::map<std::uint32_t, std::vector<std::uint32_t>> &mappings)
+    -> MappingTable {
   std::vector<char32_t> blob;
   std::vector<std::uint16_t> packed(TOTAL_CODEPOINTS, 0);
-  for (const auto &[codepoint, decomposition] : decompositions) {
+  for (const auto &[codepoint, mapping] : mappings) {
     const auto offset{blob.size()};
-    if (offset > DECOMPOSITION_OFFSET_MASK) {
-      throw std::runtime_error{
-          std::string{"canonical decomposition blob exceeds offset cap"}};
+    if (offset > MAPPING_OFFSET_MASK) {
+      throw std::runtime_error{std::string{"mapping blob exceeds offset cap"}};
+    }
+    if (mapping.size() > MAPPING_LENGTH_MAXIMUM) {
+      throw std::runtime_error{std::string{"mapping exceeds length cap"}};
     }
-    for (const auto value : decomposition) {
+    for (const auto value : mapping) {
       blob.push_back(static_cast<char32_t>(value));
     }
     packed[codepoint] = static_cast<std::uint16_t>(
-        (decomposition.size() << DECOMPOSITION_OFFSET_BITS) | offset);
+        (mapping.size() << MAPPING_OFFSET_BITS) | offset);
   }
   auto [stage1, stage2] = build_page_table<std::uint16_t>(std::span{packed});
   return {.blob = std::move(blob),
@@ -462,17 +553,17 @@ auto emit_property(std::ostream &stream, const std::string_view prefix,
   stream << "};\n\n";
 }
 
-auto emit_canonical_decomposition(std::ostream &stream,
-                                  const DecompositionTable &table) -> void {
-  stream << "constexpr char32_t CANONICAL_DECOMPOSITION_BLOB["
-         << table.blob.size() << "] = {\n";
+auto emit_mapping(std::ostream &stream, const std::string_view prefix,
+                  const MappingTable &table) -> void {
+  stream << "constexpr char32_t " << prefix << "_BLOB[" << table.blob.size()
+         << "] = {\n";
   emit_row<char32_t>(stream, table.blob, 8, EMIT_HEX);
   stream << "};\n\n";
-  stream << "constexpr std::uint16_t CANONICAL_DECOMPOSITION_STAGE1["
+  stream << "constexpr std::uint16_t " << prefix << "_STAGE1["
          << table.stage1.size() << "] = {\n";
   emit_row<std::uint16_t>(stream, table.stage1, 16, EMIT_DECIMAL);
   stream << "};\n\n";
-  stream << "constexpr std::uint16_t CANONICAL_DECOMPOSITION_STAGE2["
+  stream << "constexpr std::uint16_t " << prefix << "_STAGE2["
          << table.stage2.size() << "] = {\n";
   emit_row<std::uint16_t>(stream, table.stage2, 16, EMIT_DECIMAL);
   stream << "};\n\n";
@@ -507,7 +598,7 @@ auto main(const int argc, const char *const argv[]) -> int {
     sourcemeta::core::Options app;
     app.parse(argc, argv);
     const auto &positional{app.positional()};
-    if (positional.size() != 11) {
+    if (positional.size() != 12) {
       std::cerr
           << "Usage: " << (argc > 0 ? argv[0] : "codegen")
           << " <output.h> <PropertyValueAliases.txt>"
@@ -515,7 +606,7 @@ auto main(const int argc, const char *const argv[]) -> int {
              " <DerivedBidiClass.txt> <Scripts.txt>"
              " <DerivedGeneralCategory.txt> <DerivedNormalizationProps.txt>"
              " <UnicodeData.txt> <CompositionExclusions.txt>"
-             " <DerivedCoreProperties.txt>\n";
+             " <DerivedCoreProperties.txt> <CaseFolding.txt>\n";
       return EXIT_FAILURE;
     }
 
@@ -525,6 +616,7 @@ auto main(const int argc, const char *const argv[]) -> int {
     const std::filesystem::path unicode_data_path{positional.at(8)};
     const std::filesystem::path composition_exclusions_path{positional.at(9)};
     const std::filesystem::path core_properties_path{positional.at(10)};
+    const std::filesystem::path case_folding_path{positional.at(11)};
 
     const auto canonical_value{
         [](const std::span<const std::string_view> order) {
@@ -550,6 +642,8 @@ auto main(const int argc, const char *const argv[]) -> int {
         build_alias_map(aliases_path, "bc", canonical_value(BIDI_CLASS_ORDER))};
     const auto script_map{build_alias_map(
         aliases_path, "sc", canonical_value(UNICODE_SCRIPT_ORDER))};
+    const auto general_category_map{
+        build_alias_map(aliases_path, "gc", general_category_index)};
     const auto combining_mark_map{
         build_alias_map(aliases_path, "gc",
                         [](const std::span<const std::string_view> aliases) {
@@ -571,41 +665,57 @@ auto main(const int argc, const char *const argv[]) -> int {
       std::string_view prefix;
       std::filesystem::path input_path;
       std::optional<std::string_view> property_filter;
+      // The value of the codepoints that the file does not list, for files
+      // that do not declare such a default themselves
+      std::optional<std::string_view> default_value;
       const ValueMap &value_map;
     };
 
-    const std::array<PropertySpec, 8> properties{
+    const std::array<PropertySpec, 9> properties{
         {{.prefix = "COMBINING_CLASS",
           .input_path = positional.at(2),
           .property_filter = std::nullopt,
+          .default_value = std::nullopt,
           .value_map = combining_class_map},
          {.prefix = "JOINING_TYPE",
           .input_path = positional.at(3),
           .property_filter = std::nullopt,
+          .default_value = std::nullopt,
           .value_map = joining_type_map},
          {.prefix = "BIDI_CLASS",
           .input_path = positional.at(4),
           .property_filter = std::nullopt,
+          .default_value = std::nullopt,
           .value_map = bidi_class_map},
          {.prefix = "UNICODE_SCRIPT",
           .input_path = positional.at(5),
           .property_filter = std::nullopt,
+          .default_value = std::nullopt,
           .value_map = script_map},
+         {.prefix = "GENERAL_CATEGORY",
+          .input_path = positional.at(6),
+          .property_filter = std::nullopt,
+          .default_value = std::optional<std::string_view>{"Cn"},
+          .value_map = general_category_map},
          {.prefix = "IS_COMBINING_MARK",
           .input_path = positional.at(6),
           .property_filter = std::nullopt,
+          .default_value = std::nullopt,
           .value_map = combining_mark_map},
          {.prefix = "NFC_QUICK_CHECK",
           .input_path = normalization_props_path,
           .property_filter = std::optional<std::string_view>{"NFC_QC"},
+          .default_value = std::nullopt,
           .value_map = nfc_quick_check_map},
          {.prefix = "IS_ID_START",
           .input_path = core_properties_path,
           .property_filter = std::optional<std::string_view>{"ID_Start"},
+          .default_value = std::nullopt,
           .value_map = membership_map},
          {.prefix = "IS_ID_CONTINUE",
           .input_path = core_properties_path,
           .property_filter = std::optional<std::string_view>{"ID_Continue"},
+          .default_value = std::nullopt,
           .value_map = membership_map}}};
 
     const auto unicode_data{parse_unicode_data(unicode_data_path)};
@@ -613,23 +723,25 @@ auto main(const int argc, const char *const argv[]) -> int {
         parse_full_composition_exclusions(normalization_props_path)};
     const auto explicit_exclusions{
         parse_explicit_composition_exclusions(composition_exclusions_path)};
+    const auto case_foldings{parse_case_folding(case_folding_path)};
 
     sourcemeta::core::write_file(output_path, [&](std::ostream &stream) {
       stream << "#include <cstddef>\n";
       stream << "#include <cstdint>\n\n";
       stream << "namespace {\n\n";
       for (const auto &spec : properties) {
-        emit_property(
-            stream, spec.prefix,
-            build_pages(parse_property_file(spec.input_path, spec.value_map,
-                                            spec.property_filter)));
+        emit_property(stream, spec.prefix,
+                      build_pages(parse_property_file(
+                          spec.input_path, spec.value_map, spec.property_filter,
+                          spec.default_value)));
       }
-      emit_canonical_decomposition(stream, build_canonical_decomposition_pages(
-                                               unicode_data.decompositions));
+      emit_mapping(stream, "CANONICAL_DECOMPOSITION",
+                   build_mapping_pages(unicode_data.decompositions));
       emit_canonical_composition(stream, build_canonical_compositions(
                                              unicode_data.decompositions,
                                              unicode_data.ccc, full_exclusions,
                                              explicit_exclusions));
+      emit_mapping(stream, "CASE_FOLDING", build_mapping_pages(case_foldings));
       stream << "} // namespace\n";
     });
   } catch (const std::exception &error) {
diff --git a/vendor/core/src/core/unicode/include/sourcemeta/core/unicode.h b/vendor/core/src/core/unicode/include/sourcemeta/core/unicode.h
index 75a528e8..70ec8ed0 100644
--- a/vendor/core/src/core/unicode/include/sourcemeta/core/unicode.h
+++ b/vendor/core/src/core/unicode/include/sourcemeta/core/unicode.h
@@ -13,7 +13,7 @@
 #include <optional>    // std::optional
 #include <ostream>     // std::ostream
 #include <string>      // std::string, std::u32string, std::wstring
-#include <string_view> // std::string_view, std::wstring_view
+#include <string_view> // std::string_view, std::u32string_view, std::wstring_view
 #include <utility>     // std::pair, std::make_pair
 
 /// @defgroup unicode Unicode
@@ -587,6 +587,26 @@ auto bidi_class(const char32_t codepoint) noexcept -> BidiClass;
 SOURCEMETA_CORE_UNICODE_EXPORT
 auto script(const char32_t codepoint) noexcept -> UnicodeScript;
 
+/// @ingroup unicode
+/// Return the general category of a Unicode codepoint. Codepoints beyond
+/// U+10FFFF are reported as unassigned. See
+/// https://www.unicode.org/reports/tr44/ for the property's definition.
+/// For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/unicode.h>
+/// #include <cassert>
+///
+/// assert(sourcemeta::core::general_category(U'A') ==
+///        sourcemeta::core::GeneralCategory::UppercaseLetter);
+/// assert(sourcemeta::core::general_category(U'\u0301') ==
+///        sourcemeta::core::GeneralCategory::NonspacingMark);
+/// assert(sourcemeta::core::general_category(U' ') ==
+///        sourcemeta::core::GeneralCategory::SpaceSeparator);
+/// ```
+SOURCEMETA_CORE_UNICODE_EXPORT
+auto general_category(const char32_t codepoint) noexcept -> GeneralCategory;
+
 /// @ingroup unicode
 /// Return whether a Unicode codepoint is a combining mark, in the sense
 /// of UAX #44 general category Mn (Nonspacing_Mark), Mc (Spacing_Mark),
@@ -730,6 +750,40 @@ auto nfc(const std::u32string_view input) -> std::u32string;
 SOURCEMETA_CORE_UNICODE_EXPORT
 auto is_nfc(const std::u32string_view input) -> bool;
 
+/// @ingroup unicode
+/// Return the full case folding of a Unicode codepoint per Section 3.13 of the
+/// Unicode Standard, which takes the common and full mappings of the Unicode
+/// Character Database and never the simple or Turkic ones. The view points
+/// into static data and remains valid for the program's lifetime. An empty
+/// view means the codepoint folds to itself, which is also the case for every
+/// codepoint beyond U+10FFFF. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/unicode.h>
+/// #include <cassert>
+///
+/// assert(sourcemeta::core::case_fold(U'a').empty());
+/// assert(sourcemeta::core::case_fold(U'A') == std::u32string_view{U"a"});
+/// assert(sourcemeta::core::case_fold(U'\u00DF') ==
+///        std::u32string_view{U"ss"});
+/// ```
+SOURCEMETA_CORE_UNICODE_EXPORT
+auto case_fold(const char32_t codepoint) noexcept -> std::u32string_view;
+
+/// @ingroup unicode
+/// Return the full case folding of `input` per Section 3.13 of the Unicode
+/// Standard, folding every codepoint in turn. For example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/unicode.h>
+/// #include <cassert>
+///
+/// assert(sourcemeta::core::case_fold(U"Stra\u00DFe") == U"strasse");
+/// assert(sourcemeta::core::case_fold(U"\u0130") == U"i\u0307");
+/// ```
+SOURCEMETA_CORE_UNICODE_EXPORT
+auto case_fold(const std::u32string_view input) -> std::u32string;
+
 /// @ingroup unicode
 /// Determine the byte length of the valid UTF-8 codepoint starting at the
 /// given position within the input. Returns 1 for an ASCII byte, 2/3/4 for a
diff --git a/vendor/core/src/core/unicode/include/sourcemeta/core/unicode_ucd.h b/vendor/core/src/core/unicode/include/sourcemeta/core/unicode_ucd.h
index cb1506aa..9370f1cd 100644
--- a/vendor/core/src/core/unicode/include/sourcemeta/core/unicode_ucd.h
+++ b/vendor/core/src/core/unicode/include/sourcemeta/core/unicode_ucd.h
@@ -257,6 +257,51 @@ enum class UnicodeScript : std::uint8_t {
 #endif
 };
 
+/// @ingroup unicode
+/// Each entry maps a `GeneralCategory` enum name to its UCD short alias.
+#define SOURCEMETA_CORE_GENERAL_CATEGORY_LIST(X)                               \
+  X(UppercaseLetter, "Lu")                                                     \
+  X(LowercaseLetter, "Ll")                                                     \
+  X(TitlecaseLetter, "Lt")                                                     \
+  X(ModifierLetter, "Lm")                                                      \
+  X(OtherLetter, "Lo")                                                         \
+  X(NonspacingMark, "Mn")                                                      \
+  X(SpacingMark, "Mc")                                                         \
+  X(EnclosingMark, "Me")                                                       \
+  X(DecimalNumber, "Nd")                                                       \
+  X(LetterNumber, "Nl")                                                        \
+  X(OtherNumber, "No")                                                         \
+  X(ConnectorPunctuation, "Pc")                                                \
+  X(DashPunctuation, "Pd")                                                     \
+  X(OpenPunctuation, "Ps")                                                     \
+  X(ClosePunctuation, "Pe")                                                    \
+  X(InitialPunctuation, "Pi")                                                  \
+  X(FinalPunctuation, "Pf")                                                    \
+  X(OtherPunctuation, "Po")                                                    \
+  X(MathSymbol, "Sm")                                                          \
+  X(CurrencySymbol, "Sc")                                                      \
+  X(ModifierSymbol, "Sk")                                                      \
+  X(OtherSymbol, "So")                                                         \
+  X(SpaceSeparator, "Zs")                                                      \
+  X(LineSeparator, "Zl")                                                       \
+  X(ParagraphSeparator, "Zp")                                                  \
+  X(Control, "Cc")                                                             \
+  X(Format, "Cf")                                                              \
+  X(Surrogate, "Cs")                                                           \
+  X(PrivateUse, "Co")                                                          \
+  X(Unassigned, "Cn")
+
+/// @ingroup unicode
+/// The general category of a Unicode codepoint per UAX #44. See
+/// https://www.unicode.org/reports/tr44/ for the property's definition.
+enum class GeneralCategory : std::uint8_t {
+#if !defined(DOXYGEN)
+#define SOURCEMETA_CORE_UCD_ENUM_ENTRY(name, alias) name,
+  SOURCEMETA_CORE_GENERAL_CATEGORY_LIST(SOURCEMETA_CORE_UCD_ENUM_ENTRY)
+#undef SOURCEMETA_CORE_UCD_ENUM_ENTRY
+#endif
+};
+
 /// @ingroup unicode
 /// Each entry maps an `NFCQuickCheck` enum name to its UCD short alias.
 #define SOURCEMETA_CORE_NFC_QUICK_CHECK_LIST(X)                                \
diff --git a/vendor/core/src/core/unicode/unicode.cc b/vendor/core/src/core/unicode/unicode.cc
index 5271f654..f8d177c3 100644
--- a/vendor/core/src/core/unicode/unicode.cc
+++ b/vendor/core/src/core/unicode/unicode.cc
@@ -5,8 +5,8 @@
 #include <cstddef>     // std::size_t
 #include <cstdint>     // std::uint8_t
 #include <optional>    // std::optional, std::nullopt
-#include <string>      // std::string, std::wstring
-#include <string_view> // std::string_view, std::wstring_view
+#include <string>      // std::string, std::u32string, std::wstring
+#include <string_view> // std::string_view, std::u32string_view, std::wstring_view
 
 #if defined(_WIN32) || defined(__CYGWIN__)
 #define WIN32_LEAN_AND_MEAN
@@ -368,6 +368,15 @@ auto script(const char32_t codepoint) noexcept -> UnicodeScript {
       UNICODE_SCRIPT_STAGE2[(page << 10U) | (codepoint & 0x3FFU)]);
 }
 
+auto general_category(const char32_t codepoint) noexcept -> GeneralCategory {
+  if (codepoint > 0x10FFFF) {
+    return GeneralCategory::Unassigned;
+  }
+  const std::size_t page{GENERAL_CATEGORY_STAGE1[codepoint >> 10U]};
+  return static_cast<GeneralCategory>(
+      GENERAL_CATEGORY_STAGE2[(page << 10U) | (codepoint & 0x3FFU)]);
+}
+
 auto is_combining_mark(const char32_t codepoint) noexcept -> bool {
   if (codepoint > 0x10FFFF) {
     return false;
@@ -439,4 +448,30 @@ auto canonical_composition(const char32_t starter,
   return std::nullopt;
 }
 
+auto case_fold(const char32_t codepoint) noexcept -> std::u32string_view {
+  if (codepoint > 0x10FFFF) {
+    return {};
+  }
+  const std::size_t page{CASE_FOLDING_STAGE1[codepoint >> 10U]};
+  const std::uint16_t packed{
+      CASE_FOLDING_STAGE2[(page << 10U) | (codepoint & 0x3FFU)]};
+  const auto length{static_cast<std::size_t>(packed >> 14U)};
+  const auto offset{static_cast<std::size_t>(packed & 0x3FFFU)};
+  return std::u32string_view{CASE_FOLDING_BLOB + offset, length};
+}
+
+auto case_fold(const std::u32string_view input) -> std::u32string {
+  std::u32string result;
+  result.reserve(input.size());
+  for (const auto codepoint : input) {
+    const auto folding{case_fold(codepoint)};
+    if (folding.empty()) {
+      result.push_back(codepoint);
+    } else {
+      result.append(folding);
+    }
+  }
+  return result;
+}
+
 } // namespace sourcemeta::core
diff --git a/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h b/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h
index c509c87d..b1a40fb9 100644
--- a/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h
+++ b/vendor/core/src/lang/parallel/include/sourcemeta/core/parallel_for_each.h
@@ -38,27 +38,6 @@ inline unsigned __stdcall parallel_for_each_windows_thread_start(
   return 0;
 }
 #endif
-
-// If thread creation fails after some workers have already started, those
-// workers keep referencing the stack locals of the spawning frame, so unwinding
-// past them must be avoided. Drain the remaining tasks so the running workers
-// stop pulling new work and exit, then join every already-created worker before
-// propagating the failure
-template <typename Iterator>
-inline auto parallel_for_each_drain_and_join(std::queue<Iterator> &tasks,
-                                             std::mutex &queue_mutex,
-                                             std::vector<std::thread> &workers)
-    -> void {
-  {
-    std::scoped_lock lock{queue_mutex};
-    std::queue<Iterator> empty;
-    tasks.swap(empty);
-  }
-
-  for (auto &worker_thread : workers) {
-    worker_thread.join();
-  }
-}
 #endif
 
 /// @ingroup parallel
@@ -167,6 +146,8 @@ auto parallel_for_each(
     }
   };
 
+  const char *creation_error{nullptr};
+
   // TODO: Replace std::function with std::move_only_function once
   // Apple Clang ships libc++ 19+ (__cpp_lib_move_only_function)
 #if defined(_WIN32)
@@ -174,9 +155,9 @@ auto parallel_for_each(
     auto *heap_function = new std::function<void()>(worker_callable);
     if (stack_size_bytes > static_cast<std::size_t>(UINT_MAX)) {
       delete heap_function;
-      parallel_for_each_drain_and_join(tasks, queue_mutex, workers);
-      throw std::runtime_error(
-          "The requested stack size is too large for this platform");
+      creation_error =
+          "The requested stack size is too large for this platform";
+      break;
     }
 
     auto raw_handle = _beginthreadex(
@@ -184,8 +165,8 @@ auto parallel_for_each(
         &parallel_for_each_windows_thread_start, heap_function, 0, nullptr);
     if (raw_handle == 0) {
       delete heap_function;
-      parallel_for_each_drain_and_join(tasks, queue_mutex, workers);
-      throw std::runtime_error("Could not create thread");
+      creation_error = "Could not create thread";
+      break;
     }
 
     HANDLE thread_handle = reinterpret_cast<HANDLE>(raw_handle);
@@ -218,8 +199,8 @@ auto parallel_for_each(
     if (raw_handle != 0) {
       pthread_attr_destroy(&attr);
       delete heap_function;
-      parallel_for_each_drain_and_join(tasks, queue_mutex, workers);
-      throw std::runtime_error("Could not create thread");
+      creation_error = "Could not create thread";
+      break;
     }
     workers.emplace_back(
         [pthread_handle] { pthread_join(pthread_handle, nullptr); });
@@ -227,10 +208,25 @@ auto parallel_for_each(
   }
 #endif
 
+  // If thread creation failed after some workers have already started, those
+  // workers keep referencing the stack locals of this frame, so unwinding past
+  // them must be avoided. Drain the remaining tasks so the running workers stop
+  // pulling new work and exit, then join every already-created worker before
+  // propagating the failure
+  if (creation_error != nullptr) {
+    std::scoped_lock lock{queue_mutex};
+    std::queue<Iterator> empty;
+    tasks.swap(empty);
+  }
+
   for (auto &worker_thread : workers) {
     worker_thread.join();
   }
 
+  if (creation_error != nullptr) {
+    throw std::runtime_error(creation_error);
+  }
+
   if (exception) {
     std::rethrow_exception(exception);
   }
diff --git a/vendor/core/src/lang/process/spawn.cc b/vendor/core/src/lang/process/spawn.cc
index bb206262..906ca193 100644
--- a/vendor/core/src/lang/process/spawn.cc
+++ b/vendor/core/src/lang/process/spawn.cc
@@ -218,9 +218,6 @@ class Descriptor {
   ~Descriptor() { this->close(); }
   Descriptor(const Descriptor &) = delete;
   auto operator=(const Descriptor &) -> Descriptor & = delete;
-  Descriptor(Descriptor &&other) noexcept : value_{other.value_} {
-    other.value_ = -1;
-  }
   auto operator=(Descriptor &&other) noexcept -> Descriptor & {
     if (this != &other) {
       this->close();
@@ -361,10 +358,6 @@ auto make_pipe(Descriptor &read_end, Descriptor &write_end) -> bool {
          relocate_above_standard(write_end);
 }
 
-// On every platform this builds for, a would-block error shares its value with
-// EAGAIN
-auto is_retryable_error() -> bool { return errno == EINTR || errno == EAGAIN; }
-
 // Returns whether the stream is still open
 auto drain_stream(Descriptor &descriptor, std::string &destination) -> bool {
   std::array<char, TRANSFER_BUFFER_SIZE> buffer{};
@@ -373,7 +366,9 @@ auto drain_stream(Descriptor &descriptor, std::string &destination) -> bool {
     destination.append(buffer.data(), static_cast<std::size_t>(count));
     return true;
   }
-  if (count == -1 && is_retryable_error()) {
+  // On every platform this builds for, a would-block error shares its value
+  // with EAGAIN
+  if (count == -1 && (errno == EINTR || errno == EAGAIN)) {
     return true;
   }
 
@@ -393,7 +388,7 @@ auto write_stream(Descriptor &descriptor, const std::string_view input,
 
     return;
   }
-  if (count == -1 && is_retryable_error()) {
+  if (count == -1 && (errno == EINTR || errno == EAGAIN)) {
     return;
   }
 
diff --git a/vendor/core/vendor/libdeflate/COPYING b/vendor/core/vendor/libdeflate/COPYING
deleted file mode 100644
index 9b620b3c..00000000
--- a/vendor/core/vendor/libdeflate/COPYING
+++ /dev/null
@@ -1,22 +0,0 @@
-Copyright 2016 Eric Biggers
-Copyright 2024 Google LLC
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation files
-(the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of the Software,
-and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/vendor/core/vendor/libdeflate/common_defs.h b/vendor/core/vendor/libdeflate/common_defs.h
deleted file mode 100644
index 80307b90..00000000
--- a/vendor/core/vendor/libdeflate/common_defs.h
+++ /dev/null
@@ -1,735 +0,0 @@
-/*
- * common_defs.h
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#ifndef COMMON_DEFS_H
-#define COMMON_DEFS_H
-
-#include "libdeflate.h"
-
-#include <stdbool.h>
-#include <stddef.h>	/* for size_t */
-#include <stdint.h>
-#ifdef _MSC_VER
-#  include <intrin.h>	/* for _BitScan*() and other intrinsics */
-#  include <stdlib.h>	/* for _byteswap_*() */
-   /* Disable MSVC warnings that are expected. */
-   /* /W2 */
-#  pragma warning(disable : 4146) /* unary minus on unsigned type */
-   /* /W3 */
-#  pragma warning(disable : 4018) /* signed/unsigned mismatch */
-#  pragma warning(disable : 4244) /* possible loss of data */
-#  pragma warning(disable : 4267) /* possible loss of precision */
-#  pragma warning(disable : 4310) /* cast truncates constant value */
-   /* /W4 */
-#  pragma warning(disable : 4100) /* unreferenced formal parameter */
-#  pragma warning(disable : 4127) /* conditional expression is constant */
-#  pragma warning(disable : 4189) /* local variable initialized but not referenced */
-#  pragma warning(disable : 4232) /* nonstandard extension used */
-#  pragma warning(disable : 4245) /* conversion from 'int' to 'unsigned int' */
-#  pragma warning(disable : 4295) /* array too small to include terminating null */
-#endif
-#ifndef FREESTANDING
-#  include <string.h>	/* for memcpy() */
-#endif
-
-/* ========================================================================== */
-/*                             Target architecture                            */
-/* ========================================================================== */
-
-/* If possible, define a compiler-independent ARCH_* macro. */
-#undef ARCH_X86_64
-#undef ARCH_X86_32
-#undef ARCH_ARM64
-#undef ARCH_ARM32
-#undef ARCH_RISCV
-#ifdef _MSC_VER
-   /* Way too many things are broken in ARM64EC to pretend that it is x86_64. */
-#  if defined(_M_X64) && !defined(_M_ARM64EC)
-#    define ARCH_X86_64
-#  elif defined(_M_IX86)
-#    define ARCH_X86_32
-#  elif defined(_M_ARM64)
-#    define ARCH_ARM64
-#  elif defined(_M_ARM)
-#    define ARCH_ARM32
-#  endif
-#else
-#  if defined(__x86_64__)
-#    define ARCH_X86_64
-#  elif defined(__i386__)
-#    define ARCH_X86_32
-#  elif defined(__aarch64__)
-#    define ARCH_ARM64
-#  elif defined(__arm__)
-#    define ARCH_ARM32
-#  elif defined(__riscv)
-#    define ARCH_RISCV
-#  endif
-#endif
-
-/* ========================================================================== */
-/*                              Type definitions                              */
-/* ========================================================================== */
-
-/* Fixed-width integer types */
-typedef uint8_t u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t u64;
-typedef int8_t s8;
-typedef int16_t s16;
-typedef int32_t s32;
-typedef int64_t s64;
-
-/* ssize_t, if not available in <sys/types.h> */
-#ifdef _MSC_VER
-#  ifdef _WIN64
-     typedef long long ssize_t;
-#  else
-     typedef long ssize_t;
-#  endif
-#endif
-
-/*
- * Word type of the target architecture.  Use 'size_t' instead of
- * 'unsigned long' to account for platforms such as Windows that use 32-bit
- * 'unsigned long' on 64-bit architectures.
- */
-typedef size_t machine_word_t;
-
-/* Number of bytes in a word */
-#define WORDBYTES	((int)sizeof(machine_word_t))
-
-/* Number of bits in a word */
-#define WORDBITS	(8 * WORDBYTES)
-
-/* ========================================================================== */
-/*                         Optional compiler features                         */
-/* ========================================================================== */
-
-/* Compiler version checks.  Only use when absolutely necessary. */
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-#  define GCC_PREREQ(major, minor)		\
-	(__GNUC__ > (major) ||			\
-	 (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
-#  if !GCC_PREREQ(4, 9)
-#    error "gcc versions older than 4.9 are no longer supported"
-#  endif
-#else
-#  define GCC_PREREQ(major, minor)	0
-#endif
-#ifdef __clang__
-#  ifdef __apple_build_version__
-#    define CLANG_PREREQ(major, minor, apple_version)	\
-	(__apple_build_version__ >= (apple_version))
-#  else
-#    define CLANG_PREREQ(major, minor, apple_version)	\
-	(__clang_major__ > (major) ||			\
-	 (__clang_major__ == (major) && __clang_minor__ >= (minor)))
-#  endif
-#  if !CLANG_PREREQ(3, 9, 8000000)
-#    error "clang versions older than 3.9 are no longer supported"
-#  endif
-#else
-#  define CLANG_PREREQ(major, minor, apple_version)	0
-#endif
-#ifdef _MSC_VER
-#  define MSVC_PREREQ(version)	(_MSC_VER >= (version))
-#  if !MSVC_PREREQ(1928)
-#    error "MSVC versions older than Visual Studio 2019 v16.8 are no longer supported"
-#  endif
-#else
-#  define MSVC_PREREQ(version)	0
-#endif
-
-/*
- * __has_attribute(attribute) - check whether the compiler supports the given
- * attribute (and also supports doing the check in the first place).  Mostly
- * useful just for clang, since gcc didn't add this macro until gcc 5.
- */
-#ifndef __has_attribute
-#  define __has_attribute(attribute)	0
-#endif
-
-/*
- * __has_builtin(builtin) - check whether the compiler supports the given
- * builtin (and also supports doing the check in the first place).  Mostly
- * useful just for clang, since gcc didn't add this macro until gcc 10.
- */
-#ifndef __has_builtin
-#  define __has_builtin(builtin)	0
-#endif
-
-/* inline - suggest that a function be inlined */
-#ifdef _MSC_VER
-#  define inline		__inline
-#endif /* else assume 'inline' is usable as-is */
-
-/* forceinline - force a function to be inlined, if possible */
-#if defined(__GNUC__) || __has_attribute(always_inline)
-#  define forceinline		inline __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#  define forceinline		__forceinline
-#else
-#  define forceinline		inline
-#endif
-
-/* MAYBE_UNUSED - mark a function or variable as maybe unused */
-#if defined(__GNUC__) || __has_attribute(unused)
-#  define MAYBE_UNUSED		__attribute__((unused))
-#else
-#  define MAYBE_UNUSED
-#endif
-
-/* NORETURN - mark a function as never returning, e.g. due to calling abort() */
-#if defined(__GNUC__) || __has_attribute(noreturn)
-#  define NORETURN		__attribute__((noreturn))
-#else
-#  define NORETURN
-#endif
-
-/* likely(expr) - hint that an expression is usually true */
-#if defined(__GNUC__) || __has_builtin(__builtin_expect)
-#  define likely(expr)		__builtin_expect(!!(expr), 1)
-#else
-#  define likely(expr)		(expr)
-#endif
-
-/* unlikely(expr) - hint that an expression is usually false */
-#if defined(__GNUC__) || __has_builtin(__builtin_expect)
-#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
-#else
-#  define unlikely(expr)	(expr)
-#endif
-
-/* prefetchr(addr) - prefetch into L1 cache for read */
-#undef prefetchr
-#if defined(__GNUC__) || __has_builtin(__builtin_prefetch)
-#  define prefetchr(addr)	__builtin_prefetch((addr), 0)
-#elif defined(_MSC_VER)
-#  if defined(ARCH_X86_32) || defined(ARCH_X86_64)
-#    define prefetchr(addr)	_mm_prefetch((addr), _MM_HINT_T0)
-#  elif defined(ARCH_ARM64)
-#    define prefetchr(addr)	__prefetch2((addr), 0x00 /* prfop=PLDL1KEEP */)
-#  elif defined(ARCH_ARM32)
-#    define prefetchr(addr)	__prefetch(addr)
-#  endif
-#endif
-#ifndef prefetchr
-#  define prefetchr(addr)
-#endif
-
-/* prefetchw(addr) - prefetch into L1 cache for write */
-#undef prefetchw
-#if defined(__GNUC__) || __has_builtin(__builtin_prefetch)
-#  define prefetchw(addr)	__builtin_prefetch((addr), 1)
-#elif defined(_MSC_VER)
-#  if defined(ARCH_X86_32) || defined(ARCH_X86_64)
-#    define prefetchw(addr)	_m_prefetchw(addr)
-#  elif defined(ARCH_ARM64)
-#    define prefetchw(addr)	__prefetch2((addr), 0x10 /* prfop=PSTL1KEEP */)
-#  elif defined(ARCH_ARM32)
-#    define prefetchw(addr)	__prefetchw(addr)
-#  endif
-#endif
-#ifndef prefetchw
-#  define prefetchw(addr)
-#endif
-
-/*
- * _aligned_attribute(n) - declare that the annotated variable, or variables of
- * the annotated type, must be aligned on n-byte boundaries.
- */
-#undef _aligned_attribute
-#if defined(__GNUC__) || __has_attribute(aligned)
-#  define _aligned_attribute(n)	__attribute__((aligned(n)))
-#elif defined(_MSC_VER)
-#  define _aligned_attribute(n)	__declspec(align(n))
-#endif
-
-/*
- * _target_attribute(attrs) - override the compilation target for a function.
- *
- * This accepts one or more comma-separated suffixes to the -m prefix jointly
- * forming the name of a machine-dependent option.  On gcc-like compilers, this
- * enables codegen for the given targets, including arbitrary compiler-generated
- * code as well as the corresponding intrinsics.  On other compilers this macro
- * expands to nothing, though MSVC allows intrinsics to be used anywhere anyway.
- */
-#if defined(__GNUC__) || __has_attribute(target)
-#  define _target_attribute(attrs)	__attribute__((target(attrs)))
-#else
-#  define _target_attribute(attrs)
-#endif
-
-/* ========================================================================== */
-/*                          Miscellaneous macros                              */
-/* ========================================================================== */
-
-#define ARRAY_LEN(A)		(sizeof(A) / sizeof((A)[0]))
-#define MIN(a, b)		((a) <= (b) ? (a) : (b))
-#define MAX(a, b)		((a) >= (b) ? (a) : (b))
-#define DIV_ROUND_UP(n, d)	(((n) + (d) - 1) / (d))
-#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
-#define ALIGN(n, a)		(((n) + (a) - 1) & ~((a) - 1))
-#define ROUND_UP(n, d)		((d) * DIV_ROUND_UP((n), (d)))
-
-/* ========================================================================== */
-/*                           Endianness handling                              */
-/* ========================================================================== */
-
-/*
- * CPU_IS_LITTLE_ENDIAN() - 1 if the CPU is little endian, or 0 if it is big
- * endian.  When possible this is a compile-time macro that can be used in
- * preprocessor conditionals.  As a fallback, a generic method is used that
- * can't be used in preprocessor conditionals but should still be optimized out.
- */
-#if defined(__BYTE_ORDER__) /* gcc v4.6+ and clang */
-#  define CPU_IS_LITTLE_ENDIAN()  (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#elif defined(_MSC_VER)
-#  define CPU_IS_LITTLE_ENDIAN()  true
-#else
-static forceinline bool CPU_IS_LITTLE_ENDIAN(void)
-{
-	union {
-		u32 w;
-		u8 b;
-	} u;
-
-	u.w = 1;
-	return u.b;
-}
-#endif
-
-/* bswap16(v) - swap the bytes of a 16-bit integer */
-static forceinline u16 bswap16(u16 v)
-{
-#if defined(__GNUC__) || __has_builtin(__builtin_bswap16)
-	return __builtin_bswap16(v);
-#elif defined(_MSC_VER)
-	return _byteswap_ushort(v);
-#else
-	return (v << 8) | (v >> 8);
-#endif
-}
-
-/* bswap32(v) - swap the bytes of a 32-bit integer */
-static forceinline u32 bswap32(u32 v)
-{
-#if defined(__GNUC__) || __has_builtin(__builtin_bswap32)
-	return __builtin_bswap32(v);
-#elif defined(_MSC_VER)
-	return _byteswap_ulong(v);
-#else
-	return ((v & 0x000000FF) << 24) |
-	       ((v & 0x0000FF00) << 8) |
-	       ((v & 0x00FF0000) >> 8) |
-	       ((v & 0xFF000000) >> 24);
-#endif
-}
-
-/* bswap64(v) - swap the bytes of a 64-bit integer */
-static forceinline u64 bswap64(u64 v)
-{
-#if defined(__GNUC__) || __has_builtin(__builtin_bswap64)
-	return __builtin_bswap64(v);
-#elif defined(_MSC_VER)
-	return _byteswap_uint64(v);
-#else
-	return ((v & 0x00000000000000FF) << 56) |
-	       ((v & 0x000000000000FF00) << 40) |
-	       ((v & 0x0000000000FF0000) << 24) |
-	       ((v & 0x00000000FF000000) << 8) |
-	       ((v & 0x000000FF00000000) >> 8) |
-	       ((v & 0x0000FF0000000000) >> 24) |
-	       ((v & 0x00FF000000000000) >> 40) |
-	       ((v & 0xFF00000000000000) >> 56);
-#endif
-}
-
-#define le16_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? (v) : bswap16(v))
-#define le32_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? (v) : bswap32(v))
-#define le64_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? (v) : bswap64(v))
-#define be16_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? bswap16(v) : (v))
-#define be32_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? bswap32(v) : (v))
-#define be64_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? bswap64(v) : (v))
-
-/* ========================================================================== */
-/*                          Unaligned memory accesses                         */
-/* ========================================================================== */
-
-/*
- * UNALIGNED_ACCESS_IS_FAST() - 1 if unaligned memory accesses can be performed
- * efficiently on the target platform, otherwise 0.
- */
-#if (defined(__GNUC__) || defined(__clang__)) && \
-	(defined(ARCH_X86_64) || defined(ARCH_X86_32) || \
-	 defined(__ARM_FEATURE_UNALIGNED) || \
-	 defined(__powerpc64__) || defined(__powerpc__) || defined(__POWERPC__) || \
-	 defined(__riscv_misaligned_fast) || \
-	 /*
-	  * For all compilation purposes, WebAssembly behaves like any other CPU
-	  * instruction set. Even though WebAssembly engine might be running on
-	  * top of different actual CPU architectures, the WebAssembly spec
-	  * itself permits unaligned access and it will be fast on most of those
-	  * platforms, and simulated at the engine level on others, so it's
-	  * worth treating it as a CPU architecture with fast unaligned access.
-	  */ defined(__wasm__))
-#  define UNALIGNED_ACCESS_IS_FAST	1
-#elif defined(_MSC_VER)
-#  define UNALIGNED_ACCESS_IS_FAST	1
-#else
-#  define UNALIGNED_ACCESS_IS_FAST	0
-#endif
-
-/*
- * Implementing unaligned memory accesses using memcpy() is portable, and it
- * usually gets optimized appropriately by modern compilers.  I.e., each
- * memcpy() of 1, 2, 4, or WORDBYTES bytes gets compiled to a load or store
- * instruction, not to an actual function call.
- *
- * We no longer use the "packed struct" approach to unaligned accesses, as that
- * is nonstandard, has unclear semantics, and doesn't receive enough testing
- * (see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94994).
- *
- * arm32 with __ARM_FEATURE_UNALIGNED in gcc 5 and earlier is a known exception
- * where memcpy() generates inefficient code
- * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67366).  However, we no longer
- * consider that one case important enough to maintain different code for.
- * If you run into it, please just use a newer version of gcc (or use clang).
- */
-
-#ifdef FREESTANDING
-#  define MEMCOPY	__builtin_memcpy
-#else
-#  define MEMCOPY	memcpy
-#endif
-
-/* Unaligned loads and stores without endianness conversion */
-
-#define DEFINE_UNALIGNED_TYPE(type)				\
-static forceinline type						\
-load_##type##_unaligned(const void *p)				\
-{								\
-	type v;							\
-								\
-	MEMCOPY(&v, p, sizeof(v));				\
-	return v;						\
-}								\
-								\
-static forceinline void						\
-store_##type##_unaligned(type v, void *p)			\
-{								\
-	MEMCOPY(p, &v, sizeof(v));				\
-}
-
-DEFINE_UNALIGNED_TYPE(u16)
-DEFINE_UNALIGNED_TYPE(u32)
-DEFINE_UNALIGNED_TYPE(u64)
-DEFINE_UNALIGNED_TYPE(machine_word_t)
-
-#undef MEMCOPY
-
-#define load_word_unaligned	load_machine_word_t_unaligned
-#define store_word_unaligned	store_machine_word_t_unaligned
-
-/* Unaligned loads with endianness conversion */
-
-static forceinline u16
-get_unaligned_le16(const u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST)
-		return le16_bswap(load_u16_unaligned(p));
-	else
-		return ((u16)p[1] << 8) | p[0];
-}
-
-static forceinline u16
-get_unaligned_be16(const u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST)
-		return be16_bswap(load_u16_unaligned(p));
-	else
-		return ((u16)p[0] << 8) | p[1];
-}
-
-static forceinline u32
-get_unaligned_le32(const u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST)
-		return le32_bswap(load_u32_unaligned(p));
-	else
-		return ((u32)p[3] << 24) | ((u32)p[2] << 16) |
-			((u32)p[1] << 8) | p[0];
-}
-
-static forceinline u32
-get_unaligned_be32(const u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST)
-		return be32_bswap(load_u32_unaligned(p));
-	else
-		return ((u32)p[0] << 24) | ((u32)p[1] << 16) |
-			((u32)p[2] << 8) | p[3];
-}
-
-static forceinline u64
-get_unaligned_le64(const u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST)
-		return le64_bswap(load_u64_unaligned(p));
-	else
-		return ((u64)p[7] << 56) | ((u64)p[6] << 48) |
-			((u64)p[5] << 40) | ((u64)p[4] << 32) |
-			((u64)p[3] << 24) | ((u64)p[2] << 16) |
-			((u64)p[1] << 8) | p[0];
-}
-
-static forceinline machine_word_t
-get_unaligned_leword(const u8 *p)
-{
-	STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64);
-	if (WORDBITS == 32)
-		return get_unaligned_le32(p);
-	else
-		return get_unaligned_le64(p);
-}
-
-/* Unaligned stores with endianness conversion */
-
-static forceinline void
-put_unaligned_le16(u16 v, u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST) {
-		store_u16_unaligned(le16_bswap(v), p);
-	} else {
-		p[0] = (u8)(v >> 0);
-		p[1] = (u8)(v >> 8);
-	}
-}
-
-static forceinline void
-put_unaligned_be16(u16 v, u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST) {
-		store_u16_unaligned(be16_bswap(v), p);
-	} else {
-		p[0] = (u8)(v >> 8);
-		p[1] = (u8)(v >> 0);
-	}
-}
-
-static forceinline void
-put_unaligned_le32(u32 v, u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST) {
-		store_u32_unaligned(le32_bswap(v), p);
-	} else {
-		p[0] = (u8)(v >> 0);
-		p[1] = (u8)(v >> 8);
-		p[2] = (u8)(v >> 16);
-		p[3] = (u8)(v >> 24);
-	}
-}
-
-static forceinline void
-put_unaligned_be32(u32 v, u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST) {
-		store_u32_unaligned(be32_bswap(v), p);
-	} else {
-		p[0] = (u8)(v >> 24);
-		p[1] = (u8)(v >> 16);
-		p[2] = (u8)(v >> 8);
-		p[3] = (u8)(v >> 0);
-	}
-}
-
-static forceinline void
-put_unaligned_le64(u64 v, u8 *p)
-{
-	if (UNALIGNED_ACCESS_IS_FAST) {
-		store_u64_unaligned(le64_bswap(v), p);
-	} else {
-		p[0] = (u8)(v >> 0);
-		p[1] = (u8)(v >> 8);
-		p[2] = (u8)(v >> 16);
-		p[3] = (u8)(v >> 24);
-		p[4] = (u8)(v >> 32);
-		p[5] = (u8)(v >> 40);
-		p[6] = (u8)(v >> 48);
-		p[7] = (u8)(v >> 56);
-	}
-}
-
-static forceinline void
-put_unaligned_leword(machine_word_t v, u8 *p)
-{
-	STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64);
-	if (WORDBITS == 32)
-		put_unaligned_le32(v, p);
-	else
-		put_unaligned_le64(v, p);
-}
-
-/* ========================================================================== */
-/*                         Bit manipulation functions                         */
-/* ========================================================================== */
-
-/*
- * Bit Scan Reverse (BSR) - find the 0-based index (relative to the least
- * significant end) of the *most* significant 1 bit in the input value.  The
- * input value must be nonzero!
- */
-
-static forceinline unsigned
-bsr32(u32 v)
-{
-#if defined(__GNUC__) || __has_builtin(__builtin_clz)
-	return 31 - __builtin_clz(v);
-#elif defined(_MSC_VER)
-	unsigned long i;
-
-	_BitScanReverse(&i, v);
-	return i;
-#else
-	unsigned i = 0;
-
-	while ((v >>= 1) != 0)
-		i++;
-	return i;
-#endif
-}
-
-static forceinline unsigned
-bsr64(u64 v)
-{
-#if defined(__GNUC__) || __has_builtin(__builtin_clzll)
-	return 63 - __builtin_clzll(v);
-#elif defined(_MSC_VER) && defined(_WIN64)
-	unsigned long i;
-
-	_BitScanReverse64(&i, v);
-	return i;
-#else
-	unsigned i = 0;
-
-	while ((v >>= 1) != 0)
-		i++;
-	return i;
-#endif
-}
-
-static forceinline unsigned
-bsrw(machine_word_t v)
-{
-	STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64);
-	if (WORDBITS == 32)
-		return bsr32(v);
-	else
-		return bsr64(v);
-}
-
-/*
- * Bit Scan Forward (BSF) - find the 0-based index (relative to the least
- * significant end) of the *least* significant 1 bit in the input value.  The
- * input value must be nonzero!
- */
-
-static forceinline unsigned
-bsf32(u32 v)
-{
-#if defined(__GNUC__) || __has_builtin(__builtin_ctz)
-	return __builtin_ctz(v);
-#elif defined(_MSC_VER)
-	unsigned long i;
-
-	_BitScanForward(&i, v);
-	return i;
-#else
-	unsigned i = 0;
-
-	for (; (v & 1) == 0; v >>= 1)
-		i++;
-	return i;
-#endif
-}
-
-static forceinline unsigned
-bsf64(u64 v)
-{
-#if defined(__GNUC__) || __has_builtin(__builtin_ctzll)
-	return __builtin_ctzll(v);
-#elif defined(_MSC_VER) && defined(_WIN64)
-	unsigned long i;
-
-	_BitScanForward64(&i, v);
-	return i;
-#else
-	unsigned i = 0;
-
-	for (; (v & 1) == 0; v >>= 1)
-		i++;
-	return i;
-#endif
-}
-
-static forceinline unsigned
-bsfw(machine_word_t v)
-{
-	STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64);
-	if (WORDBITS == 32)
-		return bsf32(v);
-	else
-		return bsf64(v);
-}
-
-/*
- * rbit32(v): reverse the bits in a 32-bit integer.  This doesn't have a
- * fallback implementation; use '#ifdef rbit32' to check if this is available.
- */
-#undef rbit32
-#if (defined(__GNUC__) || defined(__clang__)) && defined(ARCH_ARM32) && \
-	(__ARM_ARCH >= 7 || (__ARM_ARCH == 6 && defined(__ARM_ARCH_6T2__)))
-static forceinline u32
-rbit32(u32 v)
-{
-	__asm__("rbit %0, %1" : "=r" (v) : "r" (v));
-	return v;
-}
-#define rbit32 rbit32
-#elif (defined(__GNUC__) || defined(__clang__)) && defined(ARCH_ARM64)
-static forceinline u32
-rbit32(u32 v)
-{
-	__asm__("rbit %w0, %w1" : "=r" (v) : "r" (v));
-	return v;
-}
-#define rbit32 rbit32
-#endif
-
-#endif /* COMMON_DEFS_H */
diff --git a/vendor/core/vendor/libdeflate/lib/adler32.c b/vendor/core/vendor/libdeflate/lib/adler32.c
deleted file mode 100644
index d5f39d8f..00000000
--- a/vendor/core/vendor/libdeflate/lib/adler32.c
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * adler32.c - Adler-32 checksum algorithm
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "lib_common.h"
-
-/* The Adler-32 divisor, or "base", value */
-#define DIVISOR 65521
-
-/*
- * MAX_CHUNK_LEN is the most bytes that can be processed without the possibility
- * of s2 overflowing when it is represented as an unsigned 32-bit integer.  This
- * value was computed using the following Python script:
- *
- *	divisor = 65521
- *	count = 0
- *	s1 = divisor - 1
- *	s2 = divisor - 1
- *	while True:
- *		s1 += 0xFF
- *		s2 += s1
- *		if s2 > 0xFFFFFFFF:
- *			break
- *		count += 1
- *	print(count)
- *
- * Note that to get the correct worst-case value, we must assume that every byte
- * has value 0xFF and that s1 and s2 started with the highest possible values
- * modulo the divisor.
- */
-#define MAX_CHUNK_LEN	5552
-
-/*
- * Update the Adler-32 values s1 and s2 using n bytes from p, update p to p + n,
- * update n to 0, and reduce s1 and s2 mod DIVISOR.  It is assumed that neither
- * s1 nor s2 can overflow before the reduction at the end, i.e. n plus any bytes
- * already processed after the last reduction must not exceed MAX_CHUNK_LEN.
- *
- * This uses only portable C code.  This is used as a fallback when a vectorized
- * implementation of Adler-32 (e.g. AVX2) is unavailable on the platform.
- *
- * Some of the vectorized implementations also use this to handle the end of the
- * data when the data isn't evenly divisible by the length the vectorized code
- * works on.  To avoid compiler errors about target-specific option mismatches
- * when this is used in that way, this is a macro rather than a function.
- *
- * Although this is unvectorized, this does include an optimization where the
- * main loop processes four bytes at a time using a strategy similar to that
- * used by vectorized implementations.  This provides increased instruction-
- * level parallelism compared to the traditional 's1 += *p++; s2 += s1;'.
- */
-#define ADLER32_CHUNK(s1, s2, p, n)					\
-do {									\
-	if (n >= 4) {							\
-		u32 s1_sum = 0;						\
-		u32 byte_0_sum = 0;					\
-		u32 byte_1_sum = 0;					\
-		u32 byte_2_sum = 0;					\
-		u32 byte_3_sum = 0;					\
-									\
-		do {							\
-			s1_sum += s1;					\
-			s1 += p[0] + p[1] + p[2] + p[3];		\
-			byte_0_sum += p[0];				\
-			byte_1_sum += p[1];				\
-			byte_2_sum += p[2];				\
-			byte_3_sum += p[3];				\
-			p += 4;						\
-			n -= 4;						\
-		} while (n >= 4);					\
-		s2 += (4 * (s1_sum + byte_0_sum)) + (3 * byte_1_sum) +	\
-		      (2 * byte_2_sum) + byte_3_sum;			\
-	}								\
-	for (; n; n--, p++) {						\
-		s1 += *p;						\
-		s2 += s1;						\
-	}								\
-	s1 %= DIVISOR;							\
-	s2 %= DIVISOR;							\
-} while (0)
-
-static u32 MAYBE_UNUSED
-adler32_generic(u32 adler, const u8 *p, size_t len)
-{
-	u32 s1 = adler & 0xFFFF;
-	u32 s2 = adler >> 16;
-
-	while (len) {
-		size_t n = MIN(len, MAX_CHUNK_LEN & ~3);
-
-		len -= n;
-		ADLER32_CHUNK(s1, s2, p, n);
-	}
-
-	return (s2 << 16) | s1;
-}
-
-/* Include architecture-specific implementation(s) if available. */
-#undef DEFAULT_IMPL
-#undef arch_select_adler32_func
-typedef u32 (*adler32_func_t)(u32 adler, const u8 *p, size_t len);
-#if defined(ARCH_ARM32) || defined(ARCH_ARM64)
-#  include "arm/adler32_impl.h"
-#elif defined(ARCH_X86_32) || defined(ARCH_X86_64)
-#  include "x86/adler32_impl.h"
-#endif
-
-#ifndef DEFAULT_IMPL
-#  define DEFAULT_IMPL adler32_generic
-#endif
-
-#ifdef arch_select_adler32_func
-static u32 dispatch_adler32(u32 adler, const u8 *p, size_t len);
-
-static volatile adler32_func_t adler32_impl = dispatch_adler32;
-
-/* Choose the best implementation at runtime. */
-static u32 dispatch_adler32(u32 adler, const u8 *p, size_t len)
-{
-	adler32_func_t f = arch_select_adler32_func();
-
-	if (f == NULL)
-		f = DEFAULT_IMPL;
-
-	adler32_impl = f;
-	return f(adler, p, len);
-}
-#else
-/* The best implementation is statically known, so call it directly. */
-#define adler32_impl DEFAULT_IMPL
-#endif
-
-LIBDEFLATEAPI u32
-libdeflate_adler32(u32 adler, const void *buffer, size_t len)
-{
-	if (buffer == NULL) /* Return initial value. */
-		return 1;
-	return adler32_impl(adler, buffer, len);
-}
diff --git a/vendor/core/vendor/libdeflate/lib/arm/adler32_impl.h b/vendor/core/vendor/libdeflate/lib/arm/adler32_impl.h
deleted file mode 100644
index 66d2f2bf..00000000
--- a/vendor/core/vendor/libdeflate/lib/arm/adler32_impl.h
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
- * arm/adler32_impl.h - ARM implementations of Adler-32 checksum algorithm
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_ARM_ADLER32_IMPL_H
-#define LIB_ARM_ADLER32_IMPL_H
-
-#include "cpu_features.h"
-
-/* Regular NEON implementation */
-#if HAVE_NEON_INTRIN && CPU_IS_LITTLE_ENDIAN()
-#  define adler32_arm_neon	adler32_arm_neon
-#  if HAVE_NEON_NATIVE
-     /*
-      * Use no attributes if none are needed, to support old versions of clang
-      * that don't accept the simd target attribute.
-      */
-#    define ATTRIBUTES
-#  elif defined(ARCH_ARM32)
-#    define ATTRIBUTES	_target_attribute("fpu=neon")
-#  elif defined(__clang__)
-#    define ATTRIBUTES	_target_attribute("simd")
-#  else
-#    define ATTRIBUTES	_target_attribute("+simd")
-#  endif
-static ATTRIBUTES MAYBE_UNUSED u32
-adler32_arm_neon(u32 adler, const u8 *p, size_t len)
-{
-	static const u16 _aligned_attribute(16) mults[64] = {
-		64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49,
-		48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
-		32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
-		16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,
-	};
-	const uint16x8_t mults_a = vld1q_u16(&mults[0]);
-	const uint16x8_t mults_b = vld1q_u16(&mults[8]);
-	const uint16x8_t mults_c = vld1q_u16(&mults[16]);
-	const uint16x8_t mults_d = vld1q_u16(&mults[24]);
-	const uint16x8_t mults_e = vld1q_u16(&mults[32]);
-	const uint16x8_t mults_f = vld1q_u16(&mults[40]);
-	const uint16x8_t mults_g = vld1q_u16(&mults[48]);
-	const uint16x8_t mults_h = vld1q_u16(&mults[56]);
-	u32 s1 = adler & 0xFFFF;
-	u32 s2 = adler >> 16;
-
-	/*
-	 * If the length is large and the pointer is misaligned, align it.
-	 * For smaller lengths, just take the misaligned load penalty.
-	 */
-	if (unlikely(len > 32768 && ((uintptr_t)p & 15))) {
-		do {
-			s1 += *p++;
-			s2 += s1;
-			len--;
-		} while ((uintptr_t)p & 15);
-		s1 %= DIVISOR;
-		s2 %= DIVISOR;
-	}
-
-	while (len) {
-		/*
-		 * Calculate the length of the next data chunk such that s1 and
-		 * s2 are guaranteed to not exceed UINT32_MAX.
-		 */
-		size_t n = MIN(len, MAX_CHUNK_LEN & ~63);
-
-		len -= n;
-
-		if (n >= 64) {
-			uint32x4_t v_s1 = vdupq_n_u32(0);
-			uint32x4_t v_s2 = vdupq_n_u32(0);
-			/*
-			 * v_byte_sums_* contain the sum of the bytes at index i
-			 * across all 64-byte segments, for each index 0..63.
-			 */
-			uint16x8_t v_byte_sums_a = vdupq_n_u16(0);
-			uint16x8_t v_byte_sums_b = vdupq_n_u16(0);
-			uint16x8_t v_byte_sums_c = vdupq_n_u16(0);
-			uint16x8_t v_byte_sums_d = vdupq_n_u16(0);
-			uint16x8_t v_byte_sums_e = vdupq_n_u16(0);
-			uint16x8_t v_byte_sums_f = vdupq_n_u16(0);
-			uint16x8_t v_byte_sums_g = vdupq_n_u16(0);
-			uint16x8_t v_byte_sums_h = vdupq_n_u16(0);
-
-			s2 += s1 * (n & ~63);
-
-			do {
-				/* Load the next 64 data bytes. */
-				const uint8x16_t data_a = vld1q_u8(p + 0);
-				const uint8x16_t data_b = vld1q_u8(p + 16);
-				const uint8x16_t data_c = vld1q_u8(p + 32);
-				const uint8x16_t data_d = vld1q_u8(p + 48);
-				uint16x8_t tmp;
-
-				/*
-				 * Accumulate the previous s1 counters into the
-				 * s2 counters.  The needed multiplication by 64
-				 * is delayed to later.
-				 */
-				v_s2 = vaddq_u32(v_s2, v_s1);
-
-				/*
-				 * Add the 64 data bytes to their v_byte_sums
-				 * counters, while also accumulating the sums of
-				 * each adjacent set of 4 bytes into v_s1.
-				 */
-				tmp = vpaddlq_u8(data_a);
-				v_byte_sums_a = vaddw_u8(v_byte_sums_a,
-							 vget_low_u8(data_a));
-				v_byte_sums_b = vaddw_u8(v_byte_sums_b,
-							 vget_high_u8(data_a));
-				tmp = vpadalq_u8(tmp, data_b);
-				v_byte_sums_c = vaddw_u8(v_byte_sums_c,
-							 vget_low_u8(data_b));
-				v_byte_sums_d = vaddw_u8(v_byte_sums_d,
-							 vget_high_u8(data_b));
-				tmp = vpadalq_u8(tmp, data_c);
-				v_byte_sums_e = vaddw_u8(v_byte_sums_e,
-							 vget_low_u8(data_c));
-				v_byte_sums_f = vaddw_u8(v_byte_sums_f,
-							 vget_high_u8(data_c));
-				tmp = vpadalq_u8(tmp, data_d);
-				v_byte_sums_g = vaddw_u8(v_byte_sums_g,
-							 vget_low_u8(data_d));
-				v_byte_sums_h = vaddw_u8(v_byte_sums_h,
-							 vget_high_u8(data_d));
-				v_s1 = vpadalq_u16(v_s1, tmp);
-
-				p += 64;
-				n -= 64;
-			} while (n >= 64);
-
-			/* s2 = 64*s2 + (64*bytesum0 + 63*bytesum1 + ... + 1*bytesum63) */
-		#ifdef ARCH_ARM32
-		#  define umlal2(a, b, c)  vmlal_u16((a), vget_high_u16(b), vget_high_u16(c))
-		#else
-		#  define umlal2	   vmlal_high_u16
-		#endif
-			v_s2 = vqshlq_n_u32(v_s2, 6);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_a),
-					 vget_low_u16(mults_a));
-			v_s2 = umlal2(v_s2, v_byte_sums_a, mults_a);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_b),
-					 vget_low_u16(mults_b));
-			v_s2 = umlal2(v_s2, v_byte_sums_b, mults_b);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_c),
-					 vget_low_u16(mults_c));
-			v_s2 = umlal2(v_s2, v_byte_sums_c, mults_c);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_d),
-					 vget_low_u16(mults_d));
-			v_s2 = umlal2(v_s2, v_byte_sums_d, mults_d);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_e),
-					 vget_low_u16(mults_e));
-			v_s2 = umlal2(v_s2, v_byte_sums_e, mults_e);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_f),
-					 vget_low_u16(mults_f));
-			v_s2 = umlal2(v_s2, v_byte_sums_f, mults_f);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_g),
-					 vget_low_u16(mults_g));
-			v_s2 = umlal2(v_s2, v_byte_sums_g, mults_g);
-			v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_h),
-					 vget_low_u16(mults_h));
-			v_s2 = umlal2(v_s2, v_byte_sums_h, mults_h);
-		#undef umlal2
-
-			/* Horizontal sum to finish up */
-		#ifdef ARCH_ARM32
-			s1 += vgetq_lane_u32(v_s1, 0) + vgetq_lane_u32(v_s1, 1) +
-			      vgetq_lane_u32(v_s1, 2) + vgetq_lane_u32(v_s1, 3);
-			s2 += vgetq_lane_u32(v_s2, 0) + vgetq_lane_u32(v_s2, 1) +
-			      vgetq_lane_u32(v_s2, 2) + vgetq_lane_u32(v_s2, 3);
-		#else
-			s1 += vaddvq_u32(v_s1);
-			s2 += vaddvq_u32(v_s2);
-		#endif
-		}
-		/*
-		 * Process the last 0 <= n < 64 bytes of the chunk using
-		 * scalar instructions and reduce s1 and s2 mod DIVISOR.
-		 */
-		ADLER32_CHUNK(s1, s2, p, n);
-	}
-	return (s2 << 16) | s1;
-}
-#undef ATTRIBUTES
-#endif /* Regular NEON implementation */
-
-/* NEON+dotprod implementation */
-#if HAVE_DOTPROD_INTRIN && CPU_IS_LITTLE_ENDIAN() && \
-	!defined(LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_DOTPROD)
-#  define adler32_arm_neon_dotprod	adler32_arm_neon_dotprod
-#  ifdef __clang__
-#    define ATTRIBUTES	_target_attribute("dotprod")
-   /*
-    * Both gcc and binutils originally considered dotprod to depend on
-    * arch=armv8.2-a or later.  This was fixed in gcc 13.2 by commit
-    * 9aac37ab8a7b ("aarch64: Remove architecture dependencies from intrinsics")
-    * and in binutils 2.41 by commit 205e4380c800 ("aarch64: Remove version
-    * dependencies from features").  Unfortunately, always using arch=armv8.2-a
-    * causes build errors with some compiler options because it may reduce the
-    * arch rather than increase it.  Therefore we try to omit the arch whenever
-    * possible.  If gcc is 14 or later, then both gcc and binutils are probably
-    * fixed, so we omit the arch.  We also omit the arch if a feature that
-    * depends on armv8.2-a or later (in gcc 13.1 and earlier) is present.
-    */
-#  elif GCC_PREREQ(14, 0) || defined(__ARM_FEATURE_JCVT) \
-			  || defined(__ARM_FEATURE_DOTPROD)
-#    define ATTRIBUTES	_target_attribute("+dotprod")
-#  else
-#    define ATTRIBUTES	_target_attribute("arch=armv8.2-a+dotprod")
-#  endif
-static ATTRIBUTES u32
-adler32_arm_neon_dotprod(u32 adler, const u8 *p, size_t len)
-{
-	static const u8 _aligned_attribute(16) mults[64] = {
-		64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49,
-		48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
-		32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
-		16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,
-	};
-	const uint8x16_t mults_a = vld1q_u8(&mults[0]);
-	const uint8x16_t mults_b = vld1q_u8(&mults[16]);
-	const uint8x16_t mults_c = vld1q_u8(&mults[32]);
-	const uint8x16_t mults_d = vld1q_u8(&mults[48]);
-	const uint8x16_t ones = vdupq_n_u8(1);
-	u32 s1 = adler & 0xFFFF;
-	u32 s2 = adler >> 16;
-
-	/*
-	 * If the length is large and the pointer is misaligned, align it.
-	 * For smaller lengths, just take the misaligned load penalty.
-	 */
-	if (unlikely(len > 32768 && ((uintptr_t)p & 15))) {
-		do {
-			s1 += *p++;
-			s2 += s1;
-			len--;
-		} while ((uintptr_t)p & 15);
-		s1 %= DIVISOR;
-		s2 %= DIVISOR;
-	}
-
-	while (len) {
-		/*
-		 * Calculate the length of the next data chunk such that s1 and
-		 * s2 are guaranteed to not exceed UINT32_MAX.
-		 */
-		size_t n = MIN(len, MAX_CHUNK_LEN & ~63);
-
-		len -= n;
-
-		if (n >= 64) {
-			uint32x4_t v_s1_a = vdupq_n_u32(0);
-			uint32x4_t v_s1_b = vdupq_n_u32(0);
-			uint32x4_t v_s1_c = vdupq_n_u32(0);
-			uint32x4_t v_s1_d = vdupq_n_u32(0);
-			uint32x4_t v_s2_a = vdupq_n_u32(0);
-			uint32x4_t v_s2_b = vdupq_n_u32(0);
-			uint32x4_t v_s2_c = vdupq_n_u32(0);
-			uint32x4_t v_s2_d = vdupq_n_u32(0);
-			uint32x4_t v_s1_sums_a = vdupq_n_u32(0);
-			uint32x4_t v_s1_sums_b = vdupq_n_u32(0);
-			uint32x4_t v_s1_sums_c = vdupq_n_u32(0);
-			uint32x4_t v_s1_sums_d = vdupq_n_u32(0);
-			uint32x4_t v_s1;
-			uint32x4_t v_s2;
-			uint32x4_t v_s1_sums;
-
-			s2 += s1 * (n & ~63);
-
-			do {
-				uint8x16_t data_a = vld1q_u8(p + 0);
-				uint8x16_t data_b = vld1q_u8(p + 16);
-				uint8x16_t data_c = vld1q_u8(p + 32);
-				uint8x16_t data_d = vld1q_u8(p + 48);
-
-				v_s1_sums_a = vaddq_u32(v_s1_sums_a, v_s1_a);
-				v_s1_a = vdotq_u32(v_s1_a, data_a, ones);
-				v_s2_a = vdotq_u32(v_s2_a, data_a, mults_a);
-
-				v_s1_sums_b = vaddq_u32(v_s1_sums_b, v_s1_b);
-				v_s1_b = vdotq_u32(v_s1_b, data_b, ones);
-				v_s2_b = vdotq_u32(v_s2_b, data_b, mults_b);
-
-				v_s1_sums_c = vaddq_u32(v_s1_sums_c, v_s1_c);
-				v_s1_c = vdotq_u32(v_s1_c, data_c, ones);
-				v_s2_c = vdotq_u32(v_s2_c, data_c, mults_c);
-
-				v_s1_sums_d = vaddq_u32(v_s1_sums_d, v_s1_d);
-				v_s1_d = vdotq_u32(v_s1_d, data_d, ones);
-				v_s2_d = vdotq_u32(v_s2_d, data_d, mults_d);
-
-				p += 64;
-				n -= 64;
-			} while (n >= 64);
-
-			v_s1 = vaddq_u32(vaddq_u32(v_s1_a, v_s1_b),
-					 vaddq_u32(v_s1_c, v_s1_d));
-			v_s2 = vaddq_u32(vaddq_u32(v_s2_a, v_s2_b),
-					 vaddq_u32(v_s2_c, v_s2_d));
-			v_s1_sums = vaddq_u32(vaddq_u32(v_s1_sums_a,
-							v_s1_sums_b),
-					      vaddq_u32(v_s1_sums_c,
-							v_s1_sums_d));
-			v_s2 = vaddq_u32(v_s2, vqshlq_n_u32(v_s1_sums, 6));
-
-			s1 += vaddvq_u32(v_s1);
-			s2 += vaddvq_u32(v_s2);
-		}
-		/*
-		 * Process the last 0 <= n < 64 bytes of the chunk using
-		 * scalar instructions and reduce s1 and s2 mod DIVISOR.
-		 */
-		ADLER32_CHUNK(s1, s2, p, n);
-	}
-	return (s2 << 16) | s1;
-}
-#undef ATTRIBUTES
-#endif /* NEON+dotprod implementation */
-
-#if defined(adler32_arm_neon_dotprod) && defined(__ARM_FEATURE_DOTPROD)
-#define DEFAULT_IMPL	adler32_arm_neon_dotprod
-#else
-static inline adler32_func_t
-arch_select_adler32_func(void)
-{
-	const u32 features MAYBE_UNUSED = get_arm_cpu_features();
-
-#ifdef adler32_arm_neon_dotprod
-	if (HAVE_NEON(features) && HAVE_DOTPROD(features))
-		return adler32_arm_neon_dotprod;
-#endif
-#ifdef adler32_arm_neon
-	if (HAVE_NEON(features))
-		return adler32_arm_neon;
-#endif
-	return NULL;
-}
-#define arch_select_adler32_func	arch_select_adler32_func
-#endif
-
-#endif /* LIB_ARM_ADLER32_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/arm/cpu_features.c b/vendor/core/vendor/libdeflate/lib/arm/cpu_features.c
deleted file mode 100644
index a4008ca9..00000000
--- a/vendor/core/vendor/libdeflate/lib/arm/cpu_features.c
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * arm/cpu_features.c - feature detection for ARM CPUs
- *
- * Copyright 2018 Eric Biggers
- *
- * 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.
- */
-
-/*
- * ARM CPUs don't have a standard way for unprivileged programs to detect CPU
- * features.  But an OS-specific way can be used when available.
- */
-
-#ifdef __APPLE__
-#  undef _ANSI_SOURCE
-#  undef _DARWIN_C_SOURCE
-#  define _DARWIN_C_SOURCE /* for sysctlbyname() */
-#endif
-
-#include "../cpu_features_common.h" /* must be included first */
-#include "cpu_features.h"
-
-#ifdef ARM_CPU_FEATURES_KNOWN
-/* Runtime ARM CPU feature detection is supported. */
-
-#ifdef __linux__
-/*
- * On Linux, arm32 and arm64 CPU features can be detected by reading the
- * AT_HWCAP and AT_HWCAP2 values from /proc/self/auxv.
- *
- * Ideally we'd use the C library function getauxval(), but it's not guaranteed
- * to be available: it was only added to glibc in 2.16, and in Android it was
- * added to API level 18 for arm32 and level 21 for arm64.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#define AT_HWCAP	16
-#define AT_HWCAP2	26
-
-static void scan_auxv(unsigned long *hwcap, unsigned long *hwcap2)
-{
-	int fd;
-	unsigned long auxbuf[32];
-	int filled = 0;
-	int i;
-
-	fd = open("/proc/self/auxv", O_RDONLY | O_CLOEXEC);
-	if (fd < 0)
-		return;
-
-	for (;;) {
-		do {
-			int ret = read(fd, &((char *)auxbuf)[filled],
-				       sizeof(auxbuf) - filled);
-			if (ret <= 0) {
-				if (ret < 0 && errno == EINTR)
-					continue;
-				goto out;
-			}
-			filled += ret;
-		} while (filled < 2 * sizeof(long));
-
-		i = 0;
-		do {
-			unsigned long type = auxbuf[i];
-			unsigned long value = auxbuf[i + 1];
-
-			if (type == AT_HWCAP)
-				*hwcap = value;
-			else if (type == AT_HWCAP2)
-				*hwcap2 = value;
-			i += 2;
-			filled -= 2 * sizeof(long);
-		} while (filled >= 2 * sizeof(long));
-
-		memmove(auxbuf, &auxbuf[i], filled);
-	}
-out:
-	close(fd);
-}
-
-static u32 query_arm_cpu_features(void)
-{
-	u32 features = 0;
-	unsigned long hwcap = 0;
-	unsigned long hwcap2 = 0;
-
-	scan_auxv(&hwcap, &hwcap2);
-
-#ifdef ARCH_ARM32
-	STATIC_ASSERT(sizeof(long) == 4);
-	if (hwcap & (1 << 12))	/* HWCAP_NEON */
-		features |= ARM_CPU_FEATURE_NEON;
-#else
-	STATIC_ASSERT(sizeof(long) == 8);
-	if (hwcap & (1 << 1))	/* HWCAP_ASIMD */
-		features |= ARM_CPU_FEATURE_NEON;
-	if (hwcap & (1 << 4))	/* HWCAP_PMULL */
-		features |= ARM_CPU_FEATURE_PMULL;
-	if (hwcap & (1 << 7))	/* HWCAP_CRC32 */
-		features |= ARM_CPU_FEATURE_CRC32;
-	if (hwcap & (1 << 17))	/* HWCAP_SHA3 */
-		features |= ARM_CPU_FEATURE_SHA3;
-	if (hwcap & (1 << 20))	/* HWCAP_ASIMDDP */
-		features |= ARM_CPU_FEATURE_DOTPROD;
-#endif
-	return features;
-}
-
-#ifdef ARCH_ARM64
-/*
- * Return whether cpu0's MIDR_EL1 identifies one of the Arm Neoverse
- * V-class server cores (V1 / V2 / V3 / V3AE).  MIDR_EL1 is exposed
- * unprivileged via sysfs (added in Linux 4.7).  Reading cpu0 only is fine
- * in practice: no Neoverse V-class server SKU has shipped as part of a
- * big.LITTLE cluster.  Any failure (file missing, read error, parse
- * failure, unrecognized CPU) returns false.
- */
-static bool arm64_cpu_is_neoverse_v_class(void)
-{
-	int fd;
-	char buf[32];
-	ssize_t n;
-	unsigned long midr;
-	u32 part;
-
-	fd = open("/sys/devices/system/cpu/cpu0/regs/identification/midr_el1",
-		  O_RDONLY | O_CLOEXEC);
-	if (fd < 0)
-		return false;
-	do {
-		n = read(fd, buf, sizeof(buf) - 1);
-	} while (n < 0 && errno == EINTR);
-	close(fd);
-	if (n <= 0)
-		return false;
-	buf[n] = '\0';
-	midr = strtoul(buf, NULL, 0); /* sysfs prints "0x%016llx\n" */
-
-	/* MIDR_EL1: [31:24]=Implementer, [15:4]=PartNum. */
-	if (((midr >> 24) & 0xff) != 0x41) /* Implementer must be Arm Ltd. */
-		return false;
-	part = (midr >> 4) & 0xfff;
-	switch (part) {
-	case 0xd40: /* Neoverse V1   (e.g. AWS Graviton 3) */
-	case 0xd4f: /* Neoverse V2   (e.g. AWS Graviton 4) */
-	case 0xd83: /* Neoverse V3AE */
-	case 0xd84: /* Neoverse V3 */
-		return true;
-	}
-	return false;
-}
-#endif /* ARCH_ARM64 */
-
-#elif defined(__APPLE__)
-/* On Apple platforms, arm64 CPU features can be detected via sysctlbyname(). */
-
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <TargetConditionals.h>
-
-static const struct {
-	const char *name;
-	u32 feature;
-} feature_sysctls[] = {
-	{ "hw.optional.neon",		  ARM_CPU_FEATURE_NEON },
-	{ "hw.optional.AdvSIMD",	  ARM_CPU_FEATURE_NEON },
-	{ "hw.optional.arm.FEAT_PMULL",	  ARM_CPU_FEATURE_PMULL },
-	{ "hw.optional.armv8_crc32",	  ARM_CPU_FEATURE_CRC32 },
-	{ "hw.optional.armv8_2_sha3",	  ARM_CPU_FEATURE_SHA3 },
-	{ "hw.optional.arm.FEAT_SHA3",	  ARM_CPU_FEATURE_SHA3 },
-	{ "hw.optional.arm.FEAT_DotProd", ARM_CPU_FEATURE_DOTPROD },
-};
-
-static u32 query_arm_cpu_features(void)
-{
-	u32 features = 0;
-	size_t i;
-
-	for (i = 0; i < ARRAY_LEN(feature_sysctls); i++) {
-		const char *name = feature_sysctls[i].name;
-		u32 val = 0;
-		size_t valsize = sizeof(val);
-
-		if (sysctlbyname(name, &val, &valsize, NULL, 0) == 0 &&
-		    valsize == sizeof(val) && val == 1)
-			features |= feature_sysctls[i].feature;
-	}
-	return features;
-}
-#elif defined(_WIN32)
-
-#include <windows.h>
-
-#ifndef PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE /* added in Windows SDK 20348 */
-#  define PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE 43
-#endif
-
-static u32 query_arm_cpu_features(void)
-{
-	u32 features = ARM_CPU_FEATURE_NEON;
-
-	if (IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE))
-		features |= ARM_CPU_FEATURE_PMULL;
-	if (IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE))
-		features |= ARM_CPU_FEATURE_CRC32;
-	if (IsProcessorFeaturePresent(PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE))
-		features |= ARM_CPU_FEATURE_DOTPROD;
-
-	/* FIXME: detect SHA3 support too. */
-
-	return features;
-}
-#else
-#error "unhandled case"
-#endif
-
-static const struct cpu_feature arm_cpu_feature_table[] = {
-	{ARM_CPU_FEATURE_NEON,		"neon"},
-	{ARM_CPU_FEATURE_PMULL,		"pmull"},
-	{ARM_CPU_FEATURE_PREFER_PMULL,  "prefer_pmull"},
-	{ARM_CPU_FEATURE_CRC32,		"crc32"},
-	{ARM_CPU_FEATURE_SHA3,		"sha3"},
-	{ARM_CPU_FEATURE_DOTPROD,	"dotprod"},
-};
-
-/*
- * Whether to set ARM_CPU_FEATURE_PREFER_PMULL on this CPU.  This is the
- * right choice on CPUs whose pmull pipes have more aggregate throughput
- * than the crc32 unit -- in measured cases by a wide margin: the Apple M
- * series sustains ~68 GB/s on pmull vs ~25 GB/s on crc32 (M1), and the Arm
- * Neoverse V class sustains ~40 GB/s vs ~22 GB/s (Graviton 4 / V2).
- *
- * We detect Apple at compile time, and Neoverse V-class cores at runtime
- * via MIDR_EL1 on Linux.  Elsewhere we leave this unset, and the dispatcher
- * picks the crc32-instruction path which is the right default for most
- * other modern ARM CPUs.
- */
-static bool arm_cpu_prefers_pmull(void)
-{
-#if defined(__APPLE__) && TARGET_OS_OSX
-	return true;
-#elif defined(__linux__) && defined(ARCH_ARM64)
-	if (arm64_cpu_is_neoverse_v_class())
-		return true;
-#endif
-#ifdef TEST_SUPPORT__DO_NOT_USE
-	return true;
-#endif
-	return false;
-}
-
-volatile u32 libdeflate_arm_cpu_features = 0;
-
-void libdeflate_init_arm_cpu_features(void)
-{
-	u32 features = query_arm_cpu_features();
-
-	if (arm_cpu_prefers_pmull())
-		features |= ARM_CPU_FEATURE_PREFER_PMULL;
-
-	disable_cpu_features_for_testing(&features, arm_cpu_feature_table,
-					 ARRAY_LEN(arm_cpu_feature_table));
-
-	libdeflate_arm_cpu_features = features | ARM_CPU_FEATURES_KNOWN;
-}
-
-#endif /* ARM_CPU_FEATURES_KNOWN */
diff --git a/vendor/core/vendor/libdeflate/lib/arm/cpu_features.h b/vendor/core/vendor/libdeflate/lib/arm/cpu_features.h
deleted file mode 100644
index dc9ab8ad..00000000
--- a/vendor/core/vendor/libdeflate/lib/arm/cpu_features.h
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * arm/cpu_features.h - feature detection for ARM CPUs
- *
- * Copyright 2018 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_ARM_CPU_FEATURES_H
-#define LIB_ARM_CPU_FEATURES_H
-
-#include "../lib_common.h"
-
-#if defined(ARCH_ARM32) || defined(ARCH_ARM64)
-
-#define ARM_CPU_FEATURE_NEON		(1 << 0)
-#define ARM_CPU_FEATURE_PMULL		(1 << 1)
-/*
- * PREFER_PMULL indicates that the CPU has very high pmull throughput, and so
- * the 12x wide pmull-based CRC-32 implementation is likely to be faster than an
- * implementation based on the crc32 instructions.
- */
-#define ARM_CPU_FEATURE_PREFER_PMULL	(1 << 2)
-#define ARM_CPU_FEATURE_CRC32		(1 << 3)
-#define ARM_CPU_FEATURE_SHA3		(1 << 4)
-#define ARM_CPU_FEATURE_DOTPROD		(1 << 5)
-
-#if !defined(FREESTANDING) && \
-    (defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)) && \
-    (defined(__linux__) || \
-     (defined(__APPLE__) && defined(ARCH_ARM64)) || \
-     (defined(_WIN32) && defined(ARCH_ARM64)))
-/* Runtime ARM CPU feature detection is supported. */
-#  define ARM_CPU_FEATURES_KNOWN	(1U << 31)
-extern volatile u32 libdeflate_arm_cpu_features;
-
-void libdeflate_init_arm_cpu_features(void);
-
-static inline u32 get_arm_cpu_features(void)
-{
-	if (libdeflate_arm_cpu_features == 0)
-		libdeflate_init_arm_cpu_features();
-	return libdeflate_arm_cpu_features;
-}
-#else
-static inline u32 get_arm_cpu_features(void) { return 0; }
-#endif
-
-/* NEON */
-#if defined(__ARM_NEON) || (defined(_MSC_VER) && defined(ARCH_ARM64))
-#  define HAVE_NEON(features)	1
-#  define HAVE_NEON_NATIVE	1
-#else
-#  define HAVE_NEON(features)	((features) & ARM_CPU_FEATURE_NEON)
-#  define HAVE_NEON_NATIVE	0
-#endif
-/*
- * With both gcc and clang, NEON intrinsics require that the main target has
- * NEON enabled already.  Exception: with gcc 6.1 and later (r230411 for arm32,
- * r226563 for arm64), hardware floating point support is sufficient.
- */
-#if (defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)) && \
-	(HAVE_NEON_NATIVE || (GCC_PREREQ(6, 1) && defined(__ARM_FP)))
-#  define HAVE_NEON_INTRIN	1
-#  include <arm_neon.h>
-#else
-#  define HAVE_NEON_INTRIN	0
-#endif
-
-/* PMULL */
-#ifdef __ARM_FEATURE_CRYPTO
-#  define HAVE_PMULL(features)	1
-#else
-#  define HAVE_PMULL(features)	((features) & ARM_CPU_FEATURE_PMULL)
-#endif
-#if defined(ARCH_ARM64) && HAVE_NEON_INTRIN && \
-	(GCC_PREREQ(7, 1) || defined(__clang__) || defined(_MSC_VER)) && \
-	CPU_IS_LITTLE_ENDIAN() /* untested on big endian */
-#  define HAVE_PMULL_INTRIN	1
-   /* Work around MSVC's vmull_p64() taking poly64x1_t instead of poly64_t */
-#  ifdef _MSC_VER
-#    define compat_vmull_p64(a, b)  vmull_p64(vcreate_p64(a), vcreate_p64(b))
-#  else
-#    define compat_vmull_p64(a, b)  vmull_p64((a), (b))
-#  endif
-#else
-#  define HAVE_PMULL_INTRIN	0
-#endif
-
-/* CRC32 */
-#ifdef __ARM_FEATURE_CRC32
-#  define HAVE_CRC32(features)	1
-#else
-#  define HAVE_CRC32(features)	((features) & ARM_CPU_FEATURE_CRC32)
-#endif
-#if defined(ARCH_ARM64) && \
-	(defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER))
-#  define HAVE_CRC32_INTRIN	1
-#  if defined(__GNUC__) || defined(__clang__)
-#    include <arm_acle.h>
-#  endif
-   /*
-    * Use an inline assembly fallback for clang 15 and earlier, which only
-    * defined the crc32 intrinsics when crc32 is enabled in the main target.
-    */
-#  if defined(__clang__) && !CLANG_PREREQ(16, 0, 16000000) && \
-	!defined(__ARM_FEATURE_CRC32)
-#    undef __crc32b
-#    define __crc32b(a, b)					\
-	({ uint32_t res;					\
-	   __asm__("crc32b %w0, %w1, %w2"			\
-		   : "=r" (res) : "r" (a), "r" (b));		\
-	   res; })
-#    undef __crc32h
-#    define __crc32h(a, b)					\
-	({ uint32_t res;					\
-	   __asm__("crc32h %w0, %w1, %w2"			\
-		   : "=r" (res) : "r" (a), "r" (b));		\
-	   res; })
-#    undef __crc32w
-#    define __crc32w(a, b)					\
-	({ uint32_t res;					\
-	   __asm__("crc32w %w0, %w1, %w2"			\
-		   : "=r" (res) : "r" (a), "r" (b));		\
-	   res; })
-#    undef __crc32d
-#    define __crc32d(a, b)					\
-	({ uint32_t res;					\
-	   __asm__("crc32x %w0, %w1, %2"			\
-		   : "=r" (res) : "r" (a), "r" (b));		\
-	   res; })
-#    pragma clang diagnostic ignored "-Wgnu-statement-expression"
-#  endif
-#else
-#  define HAVE_CRC32_INTRIN	0
-#endif
-
-/* SHA3 (needed for the eor3 instruction) */
-#ifdef __ARM_FEATURE_SHA3
-#  define HAVE_SHA3(features)	1
-#else
-#  define HAVE_SHA3(features)	((features) & ARM_CPU_FEATURE_SHA3)
-#endif
-#if defined(ARCH_ARM64) && HAVE_NEON_INTRIN && \
-	(GCC_PREREQ(9, 1) /* r268049 */ || \
-	 CLANG_PREREQ(7, 0, 10010463) /* r338010 */)
-#  define HAVE_SHA3_INTRIN	1
-   /*
-    * Use an inline assembly fallback for clang 15 and earlier, which only
-    * defined the sha3 intrinsics when sha3 is enabled in the main target.
-    */
-#  if defined(__clang__) && !CLANG_PREREQ(16, 0, 16000000) && \
-	!defined(__ARM_FEATURE_SHA3)
-#    undef veor3q_u8
-#    define veor3q_u8(a, b, c)					\
-	({ uint8x16_t res;					\
-	   __asm__("eor3 %0.16b, %1.16b, %2.16b, %3.16b"	\
-		   : "=w" (res) : "w" (a), "w" (b), "w" (c));	\
-	   res; })
-#    pragma clang diagnostic ignored "-Wgnu-statement-expression"
-#  endif
-#else
-#  define HAVE_SHA3_INTRIN	0
-#endif
-
-/* dotprod */
-#ifdef __ARM_FEATURE_DOTPROD
-#  define HAVE_DOTPROD(features)	1
-#else
-#  define HAVE_DOTPROD(features)	((features) & ARM_CPU_FEATURE_DOTPROD)
-#endif
-#if defined(ARCH_ARM64) && HAVE_NEON_INTRIN && \
-	(GCC_PREREQ(8, 1) || CLANG_PREREQ(7, 0, 10010000) || defined(_MSC_VER))
-#  define HAVE_DOTPROD_INTRIN	1
-   /*
-    * Use an inline assembly fallback for clang 15 and earlier, which only
-    * defined the dotprod intrinsics when dotprod is enabled in the main target.
-    */
-#  if defined(__clang__) && !CLANG_PREREQ(16, 0, 16000000) && \
-	!defined(__ARM_FEATURE_DOTPROD)
-#    undef vdotq_u32
-#    define vdotq_u32(a, b, c)					\
-	({ uint32x4_t res = (a);				\
-	   __asm__("udot %0.4s, %1.16b, %2.16b"			\
-		   : "+w" (res) : "w" (b), "w" (c));		\
-	   res; })
-#    pragma clang diagnostic ignored "-Wgnu-statement-expression"
-#  endif
-#else
-#  define HAVE_DOTPROD_INTRIN	0
-#endif
-
-#endif /* ARCH_ARM32 || ARCH_ARM64 */
-
-#endif /* LIB_ARM_CPU_FEATURES_H */
diff --git a/vendor/core/vendor/libdeflate/lib/arm/crc32_impl.h b/vendor/core/vendor/libdeflate/lib/arm/crc32_impl.h
deleted file mode 100644
index 696af5a8..00000000
--- a/vendor/core/vendor/libdeflate/lib/arm/crc32_impl.h
+++ /dev/null
@@ -1,594 +0,0 @@
-/*
- * arm/crc32_impl.h - ARM implementations of the gzip CRC-32 algorithm
- *
- * Copyright 2022 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_ARM_CRC32_IMPL_H
-#define LIB_ARM_CRC32_IMPL_H
-
-#include "cpu_features.h"
-
-/*
- * crc32_arm_crc() - implementation using crc32 instructions (only)
- *
- * In general this implementation is straightforward.  However, naive use of the
- * crc32 instructions is serial: one of the two inputs to each crc32 instruction
- * is the output of the previous one.  To take advantage of CPUs that can
- * execute multiple crc32 instructions in parallel, when possible we interleave
- * the checksumming of several adjacent chunks, then combine their CRCs.
- *
- * However, without pmull, combining CRCs is fairly slow.  So in this pmull-less
- * version, we only use a large chunk length, and thus we only do chunked
- * processing if there is a lot of data to checksum.  This also means that a
- * variable chunk length wouldn't help much, so we just support a fixed length.
- */
-#if HAVE_CRC32_INTRIN
-#  ifdef __clang__
-#    define ATTRIBUTES	_target_attribute("crc")
-#  else
-#    define ATTRIBUTES	_target_attribute("+crc")
-#  endif
-
-/*
- * Combine the CRCs for 4 adjacent chunks of length L = CRC32_FIXED_CHUNK_LEN
- * bytes each by computing:
- *
- *	[ crc0*x^(3*8*L) + crc1*x^(2*8*L) + crc2*x^(1*8*L) + crc3 ] mod G(x)
- *
- * This has been optimized in several ways:
- *
- *    - The needed multipliers (x to some power, reduced mod G(x)) were
- *	precomputed.
- *
- *    - The 3 multiplications are interleaved.
- *
- *    - The reduction mod G(x) is delayed to the end and done using __crc32d.
- *	Note that the use of __crc32d introduces an extra factor of x^32.  To
- *	cancel that out along with the extra factor of x^1 that gets introduced
- *	because of how the 63-bit products are aligned in their 64-bit integers,
- *	the multipliers are actually x^(j*8*L - 33) instead of x^(j*8*L).
- */
-static forceinline ATTRIBUTES u32
-combine_crcs_slow(u32 crc0, u32 crc1, u32 crc2, u32 crc3)
-{
-	u64 res0 = 0, res1 = 0, res2 = 0;
-	int i;
-
-	/* Multiply crc{0,1,2} by CRC32_FIXED_CHUNK_MULT_{3,2,1}. */
-	for (i = 0; i < 32; i++) {
-		if (CRC32_FIXED_CHUNK_MULT_3 & (1U << i))
-			res0 ^= (u64)crc0 << i;
-		if (CRC32_FIXED_CHUNK_MULT_2 & (1U << i))
-			res1 ^= (u64)crc1 << i;
-		if (CRC32_FIXED_CHUNK_MULT_1 & (1U << i))
-			res2 ^= (u64)crc2 << i;
-	}
-	/* Add the different parts and reduce mod G(x). */
-	return __crc32d(0, res0 ^ res1 ^ res2) ^ crc3;
-}
-
-#define crc32_arm_crc	crc32_arm_crc
-static ATTRIBUTES u32
-crc32_arm_crc(u32 crc, const u8 *p, size_t len)
-{
-	if (len >= 64) {
-		const size_t align = -(uintptr_t)p & 7;
-
-		/* Align p to the next 8-byte boundary. */
-		if (align) {
-			if (align & 1)
-				crc = __crc32b(crc, *p++);
-			if (align & 2) {
-				crc = __crc32h(crc, le16_bswap(*(u16 *)p));
-				p += 2;
-			}
-			if (align & 4) {
-				crc = __crc32w(crc, le32_bswap(*(u32 *)p));
-				p += 4;
-			}
-			len -= align;
-		}
-		/*
-		 * Interleave the processing of multiple adjacent data chunks to
-		 * take advantage of instruction-level parallelism.
-		 *
-		 * Some CPUs don't prefetch the data if it's being fetched in
-		 * multiple interleaved streams, so do explicit prefetching.
-		 */
-		while (len >= CRC32_NUM_CHUNKS * CRC32_FIXED_CHUNK_LEN) {
-			const u64 *wp0 = (const u64 *)p;
-			const u64 * const wp0_end =
-				(const u64 *)(p + CRC32_FIXED_CHUNK_LEN);
-			u32 crc1 = 0, crc2 = 0, crc3 = 0;
-
-			STATIC_ASSERT(CRC32_NUM_CHUNKS == 4);
-			STATIC_ASSERT(CRC32_FIXED_CHUNK_LEN % (4 * 8) == 0);
-			do {
-				prefetchr(&wp0[64 + 0*CRC32_FIXED_CHUNK_LEN/8]);
-				prefetchr(&wp0[64 + 1*CRC32_FIXED_CHUNK_LEN/8]);
-				prefetchr(&wp0[64 + 2*CRC32_FIXED_CHUNK_LEN/8]);
-				prefetchr(&wp0[64 + 3*CRC32_FIXED_CHUNK_LEN/8]);
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_FIXED_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_FIXED_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_FIXED_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_FIXED_CHUNK_LEN/8]));
-				wp0++;
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_FIXED_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_FIXED_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_FIXED_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_FIXED_CHUNK_LEN/8]));
-				wp0++;
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_FIXED_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_FIXED_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_FIXED_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_FIXED_CHUNK_LEN/8]));
-				wp0++;
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_FIXED_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_FIXED_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_FIXED_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_FIXED_CHUNK_LEN/8]));
-				wp0++;
-			} while (wp0 != wp0_end);
-			crc = combine_crcs_slow(crc, crc1, crc2, crc3);
-			p += CRC32_NUM_CHUNKS * CRC32_FIXED_CHUNK_LEN;
-			len -= CRC32_NUM_CHUNKS * CRC32_FIXED_CHUNK_LEN;
-		}
-		/*
-		 * Due to the large fixed chunk length used above, there might
-		 * still be a lot of data left.  So use a 64-byte loop here,
-		 * instead of a loop that is less unrolled.
-		 */
-		while (len >= 64) {
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 0)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 8)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 16)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 24)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 32)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 40)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 48)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 56)));
-			p += 64;
-			len -= 64;
-		}
-	}
-	if (len & 32) {
-		crc = __crc32d(crc, get_unaligned_le64(p + 0));
-		crc = __crc32d(crc, get_unaligned_le64(p + 8));
-		crc = __crc32d(crc, get_unaligned_le64(p + 16));
-		crc = __crc32d(crc, get_unaligned_le64(p + 24));
-		p += 32;
-	}
-	if (len & 16) {
-		crc = __crc32d(crc, get_unaligned_le64(p + 0));
-		crc = __crc32d(crc, get_unaligned_le64(p + 8));
-		p += 16;
-	}
-	if (len & 8) {
-		crc = __crc32d(crc, get_unaligned_le64(p));
-		p += 8;
-	}
-	if (len & 4) {
-		crc = __crc32w(crc, get_unaligned_le32(p));
-		p += 4;
-	}
-	if (len & 2) {
-		crc = __crc32h(crc, get_unaligned_le16(p));
-		p += 2;
-	}
-	if (len & 1)
-		crc = __crc32b(crc, *p);
-	return crc;
-}
-#undef ATTRIBUTES
-#endif /* crc32_arm_crc() */
-
-/*
- * crc32_arm_crc_pmullcombine() - implementation using crc32 instructions, plus
- *	pmull instructions for CRC combining
- *
- * This is similar to crc32_arm_crc(), but it enables the use of pmull
- * (carryless multiplication) instructions for the steps where the CRCs of
- * adjacent data chunks are combined.  As this greatly speeds up CRC
- * combination, this implementation also differs from crc32_arm_crc() in that it
- * uses a variable chunk length which can get fairly small.  The precomputed
- * multipliers needed for the selected chunk length are loaded from a table.
- *
- * Note that pmull is used here only for combining the CRCs of separately
- * checksummed chunks, not for folding the data itself.  See crc32_arm_pmull*()
- * for implementations that use pmull for folding the data itself.
- */
-#if HAVE_CRC32_INTRIN && HAVE_PMULL_INTRIN
-#  ifdef __clang__
-#    define ATTRIBUTES	_target_attribute("crc,aes")
-#  else
-#    define ATTRIBUTES	_target_attribute("+crc,+crypto")
-#  endif
-
-/* Do carryless multiplication of two 32-bit values. */
-static forceinline ATTRIBUTES u64
-clmul_u32(u32 a, u32 b)
-{
-	uint64x2_t res = vreinterpretq_u64_p128(
-				compat_vmull_p64((poly64_t)a, (poly64_t)b));
-
-	return vgetq_lane_u64(res, 0);
-}
-
-/*
- * Like combine_crcs_slow(), but uses vmull_p64 to do the multiplications more
- * quickly, and supports a variable chunk length.  The chunk length is
- * 'i * CRC32_MIN_VARIABLE_CHUNK_LEN'
- * where 1 <= i < ARRAY_LEN(crc32_mults_for_chunklen).
- */
-static forceinline ATTRIBUTES u32
-combine_crcs_fast(u32 crc0, u32 crc1, u32 crc2, u32 crc3, size_t i)
-{
-	u64 res0 = clmul_u32(crc0, crc32_mults_for_chunklen[i][0]);
-	u64 res1 = clmul_u32(crc1, crc32_mults_for_chunklen[i][1]);
-	u64 res2 = clmul_u32(crc2, crc32_mults_for_chunklen[i][2]);
-
-	return __crc32d(0, res0 ^ res1 ^ res2) ^ crc3;
-}
-
-#define crc32_arm_crc_pmullcombine	crc32_arm_crc_pmullcombine
-static ATTRIBUTES u32
-crc32_arm_crc_pmullcombine(u32 crc, const u8 *p, size_t len)
-{
-	const size_t align = -(uintptr_t)p & 7;
-
-	if (len >= align + CRC32_NUM_CHUNKS * CRC32_MIN_VARIABLE_CHUNK_LEN) {
-		/* Align p to the next 8-byte boundary. */
-		if (align) {
-			if (align & 1)
-				crc = __crc32b(crc, *p++);
-			if (align & 2) {
-				crc = __crc32h(crc, le16_bswap(*(u16 *)p));
-				p += 2;
-			}
-			if (align & 4) {
-				crc = __crc32w(crc, le32_bswap(*(u32 *)p));
-				p += 4;
-			}
-			len -= align;
-		}
-		/*
-		 * Handle CRC32_MAX_VARIABLE_CHUNK_LEN specially, so that better
-		 * code is generated for it.
-		 */
-		while (len >= CRC32_NUM_CHUNKS * CRC32_MAX_VARIABLE_CHUNK_LEN) {
-			const u64 *wp0 = (const u64 *)p;
-			const u64 * const wp0_end =
-				(const u64 *)(p + CRC32_MAX_VARIABLE_CHUNK_LEN);
-			u32 crc1 = 0, crc2 = 0, crc3 = 0;
-
-			STATIC_ASSERT(CRC32_NUM_CHUNKS == 4);
-			STATIC_ASSERT(CRC32_MAX_VARIABLE_CHUNK_LEN % (4 * 8) == 0);
-			do {
-				prefetchr(&wp0[64 + 0*CRC32_MAX_VARIABLE_CHUNK_LEN/8]);
-				prefetchr(&wp0[64 + 1*CRC32_MAX_VARIABLE_CHUNK_LEN/8]);
-				prefetchr(&wp0[64 + 2*CRC32_MAX_VARIABLE_CHUNK_LEN/8]);
-				prefetchr(&wp0[64 + 3*CRC32_MAX_VARIABLE_CHUNK_LEN/8]);
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				wp0++;
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				wp0++;
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				wp0++;
-				crc  = __crc32d(crc,  le64_bswap(wp0[0*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc1 = __crc32d(crc1, le64_bswap(wp0[1*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc2 = __crc32d(crc2, le64_bswap(wp0[2*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				crc3 = __crc32d(crc3, le64_bswap(wp0[3*CRC32_MAX_VARIABLE_CHUNK_LEN/8]));
-				wp0++;
-			} while (wp0 != wp0_end);
-			crc = combine_crcs_fast(crc, crc1, crc2, crc3,
-						ARRAY_LEN(crc32_mults_for_chunklen) - 1);
-			p += CRC32_NUM_CHUNKS * CRC32_MAX_VARIABLE_CHUNK_LEN;
-			len -= CRC32_NUM_CHUNKS * CRC32_MAX_VARIABLE_CHUNK_LEN;
-		}
-		/* Handle up to one variable-length chunk. */
-		if (len >= CRC32_NUM_CHUNKS * CRC32_MIN_VARIABLE_CHUNK_LEN) {
-			const size_t i = len / (CRC32_NUM_CHUNKS *
-						CRC32_MIN_VARIABLE_CHUNK_LEN);
-			const size_t chunk_len =
-				i * CRC32_MIN_VARIABLE_CHUNK_LEN;
-			const u64 *wp0 = (const u64 *)(p + 0*chunk_len);
-			const u64 *wp1 = (const u64 *)(p + 1*chunk_len);
-			const u64 *wp2 = (const u64 *)(p + 2*chunk_len);
-			const u64 *wp3 = (const u64 *)(p + 3*chunk_len);
-			const u64 * const wp0_end = wp1;
-			u32 crc1 = 0, crc2 = 0, crc3 = 0;
-
-			STATIC_ASSERT(CRC32_NUM_CHUNKS == 4);
-			STATIC_ASSERT(CRC32_MIN_VARIABLE_CHUNK_LEN % (4 * 8) == 0);
-			do {
-				prefetchr(wp0 + 64);
-				prefetchr(wp1 + 64);
-				prefetchr(wp2 + 64);
-				prefetchr(wp3 + 64);
-				crc  = __crc32d(crc,  le64_bswap(*wp0++));
-				crc1 = __crc32d(crc1, le64_bswap(*wp1++));
-				crc2 = __crc32d(crc2, le64_bswap(*wp2++));
-				crc3 = __crc32d(crc3, le64_bswap(*wp3++));
-				crc  = __crc32d(crc,  le64_bswap(*wp0++));
-				crc1 = __crc32d(crc1, le64_bswap(*wp1++));
-				crc2 = __crc32d(crc2, le64_bswap(*wp2++));
-				crc3 = __crc32d(crc3, le64_bswap(*wp3++));
-				crc  = __crc32d(crc,  le64_bswap(*wp0++));
-				crc1 = __crc32d(crc1, le64_bswap(*wp1++));
-				crc2 = __crc32d(crc2, le64_bswap(*wp2++));
-				crc3 = __crc32d(crc3, le64_bswap(*wp3++));
-				crc  = __crc32d(crc,  le64_bswap(*wp0++));
-				crc1 = __crc32d(crc1, le64_bswap(*wp1++));
-				crc2 = __crc32d(crc2, le64_bswap(*wp2++));
-				crc3 = __crc32d(crc3, le64_bswap(*wp3++));
-			} while (wp0 != wp0_end);
-			crc = combine_crcs_fast(crc, crc1, crc2, crc3, i);
-			p += CRC32_NUM_CHUNKS * chunk_len;
-			len -= CRC32_NUM_CHUNKS * chunk_len;
-		}
-
-		while (len >= 32) {
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 0)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 8)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 16)));
-			crc = __crc32d(crc, le64_bswap(*(u64 *)(p + 24)));
-			p += 32;
-			len -= 32;
-		}
-	} else {
-		while (len >= 32) {
-			crc = __crc32d(crc, get_unaligned_le64(p + 0));
-			crc = __crc32d(crc, get_unaligned_le64(p + 8));
-			crc = __crc32d(crc, get_unaligned_le64(p + 16));
-			crc = __crc32d(crc, get_unaligned_le64(p + 24));
-			p += 32;
-			len -= 32;
-		}
-	}
-	if (len & 16) {
-		crc = __crc32d(crc, get_unaligned_le64(p + 0));
-		crc = __crc32d(crc, get_unaligned_le64(p + 8));
-		p += 16;
-	}
-	if (len & 8) {
-		crc = __crc32d(crc, get_unaligned_le64(p));
-		p += 8;
-	}
-	if (len & 4) {
-		crc = __crc32w(crc, get_unaligned_le32(p));
-		p += 4;
-	}
-	if (len & 2) {
-		crc = __crc32h(crc, get_unaligned_le16(p));
-		p += 2;
-	}
-	if (len & 1)
-		crc = __crc32b(crc, *p);
-	return crc;
-}
-#undef ATTRIBUTES
-#endif /* crc32_arm_crc_pmullcombine() */
-
-/*
- * crc32_arm_pmullx4() - implementation using "folding" with pmull instructions
- *
- * This implementation is intended for CPUs that support pmull instructions but
- * not crc32 instructions.
- */
-#if HAVE_PMULL_INTRIN
-#  define crc32_arm_pmullx4	crc32_arm_pmullx4
-#  define SUFFIX			 _pmullx4
-#  ifdef __clang__
-     /*
-      * This used to use "crypto", but that stopped working with clang 16.
-      * Now only "aes" works.  "aes" works with older versions too, so use
-      * that.  No "+" prefix; clang 15 and earlier doesn't accept that.
-      */
-#    define ATTRIBUTES	_target_attribute("aes")
-#  else
-     /*
-      * With gcc, only "+crypto" works.  Both the "+" prefix and the
-      * "crypto" (not "aes") are essential...
-      */
-#    define ATTRIBUTES	_target_attribute("+crypto")
-#  endif
-#  define ENABLE_EOR3		0
-#  include "crc32_pmull_helpers.h"
-
-static ATTRIBUTES u32
-crc32_arm_pmullx4(u32 crc, const u8 *p, size_t len)
-{
-	static const u64 _aligned_attribute(16) mults[3][2] = {
-		{ CRC32_X159_MODG, CRC32_X95_MODG },  /* 1 vecs */
-		{ CRC32_X543_MODG, CRC32_X479_MODG }, /* 4 vecs */
-		{ CRC32_X287_MODG, CRC32_X223_MODG }, /* 2 vecs */
-	};
-	static const u64 _aligned_attribute(16) barrett_consts[3][2] = {
-		{ CRC32_X95_MODG, },
-		{ CRC32_BARRETT_CONSTANT_1, },
-		{ CRC32_BARRETT_CONSTANT_2, },
-	};
-	const poly64x2_t multipliers_1 = load_multipliers(mults[0]);
-	uint8x16_t v0, v1, v2, v3;
-
-	if (len < 64 + 15) {
-		if (len < 16)
-			return crc32_slice1(crc, p, len);
-		v0 = veorq_u8(vld1q_u8(p), u32_to_bytevec(crc));
-		p += 16;
-		len -= 16;
-		while (len >= 16) {
-			v0 = fold_vec(v0, vld1q_u8(p), multipliers_1);
-			p += 16;
-			len -= 16;
-		}
-	} else {
-		const poly64x2_t multipliers_4 = load_multipliers(mults[1]);
-		const poly64x2_t multipliers_2 = load_multipliers(mults[2]);
-		const size_t align = -(uintptr_t)p & 15;
-		const uint8x16_t *vp;
-
-		v0 = veorq_u8(vld1q_u8(p), u32_to_bytevec(crc));
-		p += 16;
-		/* Align p to the next 16-byte boundary. */
-		if (align) {
-			v0 = fold_partial_vec(v0, p, align, multipliers_1);
-			p += align;
-			len -= align;
-		}
-		vp = (const uint8x16_t *)p;
-		v1 = *vp++;
-		v2 = *vp++;
-		v3 = *vp++;
-		while (len >= 64 + 64) {
-			v0 = fold_vec(v0, *vp++, multipliers_4);
-			v1 = fold_vec(v1, *vp++, multipliers_4);
-			v2 = fold_vec(v2, *vp++, multipliers_4);
-			v3 = fold_vec(v3, *vp++, multipliers_4);
-			len -= 64;
-		}
-		v0 = fold_vec(v0, v2, multipliers_2);
-		v1 = fold_vec(v1, v3, multipliers_2);
-		if (len & 32) {
-			v0 = fold_vec(v0, *vp++, multipliers_2);
-			v1 = fold_vec(v1, *vp++, multipliers_2);
-		}
-		v0 = fold_vec(v0, v1, multipliers_1);
-		if (len & 16)
-			v0 = fold_vec(v0, *vp++, multipliers_1);
-		p = (const u8 *)vp;
-		len &= 15;
-	}
-
-	/* Handle any remaining partial block now before reducing to 32 bits. */
-	if (len)
-		v0 = fold_partial_vec(v0, p, len, multipliers_1);
-
-	/* Reduce to 32 bits, following lib/x86/crc32_pclmul_template.h */
-	v0 = veorq_u8(clmul_low(v0, load_multipliers(barrett_consts[0])),
-		      vextq_u8(v0, vdupq_n_u8(0), 8));
-	v1 = clmul_low(v0, load_multipliers(barrett_consts[1]));
-	v1 = clmul_low(v1, load_multipliers(barrett_consts[2]));
-	v0 = veorq_u8(v0, v1);
-	return vgetq_lane_u32(vreinterpretq_u32_u8(v0), 2);
-}
-#undef SUFFIX
-#undef ATTRIBUTES
-#undef ENABLE_EOR3
-#endif /* crc32_arm_pmullx4() */
-
-/*
- * crc32_arm_pmullx12_crc() - large-stride implementation using "folding" with
- *	pmull instructions, where crc32 instructions are also available
- *
- * See crc32_pmull_wide.h for explanation.
- */
-#if HAVE_PMULL_INTRIN && HAVE_CRC32_INTRIN
-#  define crc32_arm_pmullx12_crc	crc32_arm_pmullx12_crc
-#  define SUFFIX				 _pmullx12_crc
-#  ifdef __clang__
-#    define ATTRIBUTES	_target_attribute("aes,crc")
-#  else
-#    define ATTRIBUTES	_target_attribute("+crypto,+crc")
-#  endif
-#  define ENABLE_EOR3	0
-#  include "crc32_pmull_wide.h"
-#endif
-
-/*
- * crc32_arm_pmullx12_crc_eor3()
- *
- * This like crc32_arm_pmullx12_crc(), but it adds the eor3 instruction (from
- * the sha3 extension) for even better performance.
- */
-#if HAVE_PMULL_INTRIN && HAVE_CRC32_INTRIN && HAVE_SHA3_INTRIN && \
-	!defined(LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_SHA3)
-#  define crc32_arm_pmullx12_crc_eor3	crc32_arm_pmullx12_crc_eor3
-#  define SUFFIX				 _pmullx12_crc_eor3
-#  ifdef __clang__
-#    define ATTRIBUTES	_target_attribute("aes,crc,sha3")
-   /*
-    * Both gcc and binutils originally considered sha3 to depend on
-    * arch=armv8.2-a or later.  This was fixed in gcc 13.2 by commit
-    * 9aac37ab8a7b ("aarch64: Remove architecture dependencies from intrinsics")
-    * and in binutils 2.41 by commit 205e4380c800 ("aarch64: Remove version
-    * dependencies from features").  Unfortunately, always using arch=armv8.2-a
-    * causes build errors with some compiler options because it may reduce the
-    * arch rather than increase it.  Therefore we try to omit the arch whenever
-    * possible.  If gcc is 14 or later, then both gcc and binutils are probably
-    * fixed, so we omit the arch.  We also omit the arch if a feature that
-    * depends on armv8.2-a or later (in gcc 13.1 and earlier) is present.
-    */
-#  elif GCC_PREREQ(14, 0) || defined(__ARM_FEATURE_JCVT) \
-			  || defined(__ARM_FEATURE_DOTPROD)
-#    define ATTRIBUTES	_target_attribute("+crypto,+crc,+sha3")
-#  else
-#    define ATTRIBUTES	_target_attribute("arch=armv8.2-a+crypto+crc+sha3")
-#  endif
-#  define ENABLE_EOR3	1
-#  include "crc32_pmull_wide.h"
-#endif
-
-static inline crc32_func_t
-arch_select_crc32_func(void)
-{
-	const u32 features MAYBE_UNUSED = get_arm_cpu_features();
-
-#ifdef crc32_arm_pmullx12_crc_eor3
-	if ((features & ARM_CPU_FEATURE_PREFER_PMULL) &&
-	    HAVE_PMULL(features) && HAVE_CRC32(features) && HAVE_SHA3(features))
-		return crc32_arm_pmullx12_crc_eor3;
-#endif
-#ifdef crc32_arm_pmullx12_crc
-	if ((features & ARM_CPU_FEATURE_PREFER_PMULL) &&
-	    HAVE_PMULL(features) && HAVE_CRC32(features))
-		return crc32_arm_pmullx12_crc;
-#endif
-#ifdef crc32_arm_crc_pmullcombine
-	if (HAVE_CRC32(features) && HAVE_PMULL(features))
-		return crc32_arm_crc_pmullcombine;
-#endif
-#ifdef crc32_arm_crc
-	if (HAVE_CRC32(features))
-		return crc32_arm_crc;
-#endif
-#ifdef crc32_arm_pmullx4
-	if (HAVE_PMULL(features))
-		return crc32_arm_pmullx4;
-#endif
-	return NULL;
-}
-#define arch_select_crc32_func	arch_select_crc32_func
-
-#endif /* LIB_ARM_CRC32_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/arm/crc32_pmull_helpers.h b/vendor/core/vendor/libdeflate/lib/arm/crc32_pmull_helpers.h
deleted file mode 100644
index 023b9044..00000000
--- a/vendor/core/vendor/libdeflate/lib/arm/crc32_pmull_helpers.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * arm/crc32_pmull_helpers.h - helper functions for CRC-32 folding with PMULL
- *
- * Copyright 2022 Eric Biggers
- *
- * 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.
- */
-
-/*
- * This file is a "template" for instantiating helper functions for CRC folding
- * with pmull instructions.  It accepts the following parameters:
- *
- * SUFFIX:
- *	Name suffix to append to all instantiated functions.
- * ATTRIBUTES:
- *	Target function attributes to use.
- * ENABLE_EOR3:
- *	Use the eor3 instruction (from the sha3 extension).
- */
-
-/* Create a vector with 'a' in the first 4 bytes, and the rest zeroed out. */
-#undef u32_to_bytevec
-static forceinline ATTRIBUTES uint8x16_t
-ADD_SUFFIX(u32_to_bytevec)(u32 a)
-{
-	return vreinterpretq_u8_u32(vsetq_lane_u32(a, vdupq_n_u32(0), 0));
-}
-#define u32_to_bytevec	ADD_SUFFIX(u32_to_bytevec)
-
-/* Load two 64-bit values into a vector. */
-#undef load_multipliers
-static forceinline ATTRIBUTES poly64x2_t
-ADD_SUFFIX(load_multipliers)(const u64 p[2])
-{
-	return vreinterpretq_p64_u64(vld1q_u64(p));
-}
-#define load_multipliers	ADD_SUFFIX(load_multipliers)
-
-/* Do carryless multiplication of the low halves of two vectors. */
-#undef clmul_low
-static forceinline ATTRIBUTES uint8x16_t
-ADD_SUFFIX(clmul_low)(uint8x16_t a, poly64x2_t b)
-{
-	return vreinterpretq_u8_p128(
-		     compat_vmull_p64(vgetq_lane_p64(vreinterpretq_p64_u8(a), 0),
-				      vgetq_lane_p64(b, 0)));
-}
-#define clmul_low	ADD_SUFFIX(clmul_low)
-
-/* Do carryless multiplication of the high halves of two vectors. */
-#undef clmul_high
-static forceinline ATTRIBUTES uint8x16_t
-ADD_SUFFIX(clmul_high)(uint8x16_t a, poly64x2_t b)
-{
-#ifdef __clang__
-	/*
-	 * Use inline asm to ensure that pmull2 is really used.  This works
-	 * around clang bug https://github.com/llvm/llvm-project/issues/52868.
-	 */
-	uint8x16_t res;
-
-	__asm__("pmull2 %0.1q, %1.2d, %2.2d" : "=w" (res) : "w" (a), "w" (b));
-	return res;
-#else
-	return vreinterpretq_u8_p128(vmull_high_p64(vreinterpretq_p64_u8(a), b));
-#endif
-}
-#define clmul_high	ADD_SUFFIX(clmul_high)
-
-#undef eor3
-static forceinline ATTRIBUTES uint8x16_t
-ADD_SUFFIX(eor3)(uint8x16_t a, uint8x16_t b, uint8x16_t c)
-{
-#if ENABLE_EOR3
-	return veor3q_u8(a, b, c);
-#else
-	return veorq_u8(veorq_u8(a, b), c);
-#endif
-}
-#define eor3	ADD_SUFFIX(eor3)
-
-#undef fold_vec
-static forceinline ATTRIBUTES uint8x16_t
-ADD_SUFFIX(fold_vec)(uint8x16_t src, uint8x16_t dst, poly64x2_t multipliers)
-{
-	uint8x16_t a = clmul_low(src, multipliers);
-	uint8x16_t b = clmul_high(src, multipliers);
-
-	return eor3(a, b, dst);
-}
-#define fold_vec	ADD_SUFFIX(fold_vec)
-
-/*
- * Given v containing a 16-byte polynomial, and a pointer 'p' that points to the
- * next '1 <= len <= 15' data bytes, rearrange the concatenation of v and the
- * data into vectors x0 and x1 that contain 'len' bytes and 16 bytes,
- * respectively.  Then fold x0 into x1 and return the result.  Assumes that
- * 'p + len - 16' is in-bounds.
- */
-#undef fold_partial_vec
-static forceinline ATTRIBUTES MAYBE_UNUSED uint8x16_t
-ADD_SUFFIX(fold_partial_vec)(uint8x16_t v, const u8 *p, size_t len,
-			     poly64x2_t multipliers_1)
-{
-	/*
-	 * vqtbl1q_u8(v, shift_tab[len..len+15]) left shifts v by 16-len bytes.
-	 * vqtbl1q_u8(v, shift_tab[len+16..len+31]) right shifts v by len bytes.
-	 */
-	static const u8 shift_tab[48] = {
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-		0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	};
-	const uint8x16_t lshift = vld1q_u8(&shift_tab[len]);
-	const uint8x16_t rshift = vld1q_u8(&shift_tab[len + 16]);
-	uint8x16_t x0, x1, bsl_mask;
-
-	/* x0 = v left-shifted by '16 - len' bytes */
-	x0 = vqtbl1q_u8(v, lshift);
-
-	/* Create a vector of '16 - len' 0x00 bytes, then 'len' 0xff bytes. */
-	bsl_mask = vreinterpretq_u8_s8(
-			vshrq_n_s8(vreinterpretq_s8_u8(rshift), 7));
-
-	/*
-	 * x1 = the last '16 - len' bytes from v (i.e. v right-shifted by 'len'
-	 * bytes) followed by the remaining data.
-	 */
-	x1 = vbslq_u8(bsl_mask /* 0 bits select from arg3, 1 bits from arg2 */,
-		      vld1q_u8(p + len - 16), vqtbl1q_u8(v, rshift));
-
-	return fold_vec(x0, x1, multipliers_1);
-}
-#define fold_partial_vec	ADD_SUFFIX(fold_partial_vec)
diff --git a/vendor/core/vendor/libdeflate/lib/arm/crc32_pmull_wide.h b/vendor/core/vendor/libdeflate/lib/arm/crc32_pmull_wide.h
deleted file mode 100644
index 300e2829..00000000
--- a/vendor/core/vendor/libdeflate/lib/arm/crc32_pmull_wide.h
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * arm/crc32_pmull_wide.h - gzip CRC-32 with PMULL (extra-wide version)
- *
- * Copyright 2022 Eric Biggers
- *
- * 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.
- */
-
-/*
- * This file is a "template" for instantiating PMULL-based crc32_arm functions.
- * The "parameters" are:
- *
- * SUFFIX:
- *	Name suffix to append to all instantiated functions.
- * ATTRIBUTES:
- *	Target function attributes to use.
- * ENABLE_EOR3:
- *	Use the eor3 instruction (from the sha3 extension).
- *
- * This is the extra-wide version; it uses an unusually large stride length of
- * 12, and it assumes that crc32 instructions are available too.  It's intended
- * for powerful CPUs that support both pmull and crc32 instructions, but where
- * throughput of pmull and xor (given enough instructions issued in parallel) is
- * significantly higher than that of crc32, thus making the crc32 instructions
- * (counterintuitively) not actually the fastest way to compute the CRC-32.  The
- * Apple M1 processor is an example of such a CPU.
- */
-
-#include "crc32_pmull_helpers.h"
-
-static ATTRIBUTES u32
-ADD_SUFFIX(crc32_arm)(u32 crc, const u8 *p, size_t len)
-{
-	uint8x16_t v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11;
-
-	if (len < 3 * 192) {
-		static const u64 _aligned_attribute(16) mults[3][2] = {
-			{ CRC32_X543_MODG, CRC32_X479_MODG }, /* 4 vecs */
-			{ CRC32_X287_MODG, CRC32_X223_MODG }, /* 2 vecs */
-			{ CRC32_X159_MODG, CRC32_X95_MODG },  /* 1 vecs */
-		};
-		poly64x2_t multipliers_4, multipliers_2, multipliers_1;
-
-		if (len < 64)
-			goto tail;
-		multipliers_4 = load_multipliers(mults[0]);
-		multipliers_2 = load_multipliers(mults[1]);
-		multipliers_1 = load_multipliers(mults[2]);
-		/*
-		 * Short length; don't bother aligning the pointer, and fold
-		 * 64 bytes (4 vectors) at a time, at most.
-		 */
-		v0 = veorq_u8(vld1q_u8(p + 0), u32_to_bytevec(crc));
-		v1 = vld1q_u8(p + 16);
-		v2 = vld1q_u8(p + 32);
-		v3 = vld1q_u8(p + 48);
-		p += 64;
-		len -= 64;
-		while (len >= 64) {
-			v0 = fold_vec(v0, vld1q_u8(p + 0), multipliers_4);
-			v1 = fold_vec(v1, vld1q_u8(p + 16), multipliers_4);
-			v2 = fold_vec(v2, vld1q_u8(p + 32), multipliers_4);
-			v3 = fold_vec(v3, vld1q_u8(p + 48), multipliers_4);
-			p += 64;
-			len -= 64;
-		}
-		v0 = fold_vec(v0, v2, multipliers_2);
-		v1 = fold_vec(v1, v3, multipliers_2);
-		if (len >= 32) {
-			v0 = fold_vec(v0, vld1q_u8(p + 0), multipliers_2);
-			v1 = fold_vec(v1, vld1q_u8(p + 16), multipliers_2);
-			p += 32;
-			len -= 32;
-		}
-		v0 = fold_vec(v0, v1, multipliers_1);
-	} else {
-		static const u64 _aligned_attribute(16) mults[4][2] = {
-			{ CRC32_X1567_MODG, CRC32_X1503_MODG }, /* 12 vecs */
-			{ CRC32_X799_MODG, CRC32_X735_MODG },   /* 6 vecs */
-			{ CRC32_X415_MODG, CRC32_X351_MODG },   /* 3 vecs */
-			{ CRC32_X159_MODG, CRC32_X95_MODG },    /* 1 vecs */
-		};
-		const poly64x2_t multipliers_12 = load_multipliers(mults[0]);
-		const poly64x2_t multipliers_6 = load_multipliers(mults[1]);
-		const poly64x2_t multipliers_3 = load_multipliers(mults[2]);
-		const poly64x2_t multipliers_1 = load_multipliers(mults[3]);
-		const size_t align = -(uintptr_t)p & 15;
-		const uint8x16_t *vp;
-
-		/* Align p to the next 16-byte boundary. */
-		if (align) {
-			if (align & 1)
-				crc = __crc32b(crc, *p++);
-			if (align & 2) {
-				crc = __crc32h(crc, le16_bswap(*(u16 *)p));
-				p += 2;
-			}
-			if (align & 4) {
-				crc = __crc32w(crc, le32_bswap(*(u32 *)p));
-				p += 4;
-			}
-			if (align & 8) {
-				crc = __crc32d(crc, le64_bswap(*(u64 *)p));
-				p += 8;
-			}
-			len -= align;
-		}
-		vp = (const uint8x16_t *)p;
-		v0 = veorq_u8(*vp++, u32_to_bytevec(crc));
-		v1 = *vp++;
-		v2 = *vp++;
-		v3 = *vp++;
-		v4 = *vp++;
-		v5 = *vp++;
-		v6 = *vp++;
-		v7 = *vp++;
-		v8 = *vp++;
-		v9 = *vp++;
-		v10 = *vp++;
-		v11 = *vp++;
-		len -= 192;
-		/* Fold 192 bytes (12 vectors) at a time. */
-		do {
-			v0 = fold_vec(v0, *vp++, multipliers_12);
-			v1 = fold_vec(v1, *vp++, multipliers_12);
-			v2 = fold_vec(v2, *vp++, multipliers_12);
-			v3 = fold_vec(v3, *vp++, multipliers_12);
-			v4 = fold_vec(v4, *vp++, multipliers_12);
-			v5 = fold_vec(v5, *vp++, multipliers_12);
-			v6 = fold_vec(v6, *vp++, multipliers_12);
-			v7 = fold_vec(v7, *vp++, multipliers_12);
-			v8 = fold_vec(v8, *vp++, multipliers_12);
-			v9 = fold_vec(v9, *vp++, multipliers_12);
-			v10 = fold_vec(v10, *vp++, multipliers_12);
-			v11 = fold_vec(v11, *vp++, multipliers_12);
-			len -= 192;
-		} while (len >= 192);
-
-		/*
-		 * Fewer than 192 bytes left.  Fold v0-v11 down to just v0,
-		 * while processing up to 144 more bytes.
-		 */
-		v0 = fold_vec(v0, v6, multipliers_6);
-		v1 = fold_vec(v1, v7, multipliers_6);
-		v2 = fold_vec(v2, v8, multipliers_6);
-		v3 = fold_vec(v3, v9, multipliers_6);
-		v4 = fold_vec(v4, v10, multipliers_6);
-		v5 = fold_vec(v5, v11, multipliers_6);
-		if (len >= 96) {
-			v0 = fold_vec(v0, *vp++, multipliers_6);
-			v1 = fold_vec(v1, *vp++, multipliers_6);
-			v2 = fold_vec(v2, *vp++, multipliers_6);
-			v3 = fold_vec(v3, *vp++, multipliers_6);
-			v4 = fold_vec(v4, *vp++, multipliers_6);
-			v5 = fold_vec(v5, *vp++, multipliers_6);
-			len -= 96;
-		}
-		v0 = fold_vec(v0, v3, multipliers_3);
-		v1 = fold_vec(v1, v4, multipliers_3);
-		v2 = fold_vec(v2, v5, multipliers_3);
-		if (len >= 48) {
-			v0 = fold_vec(v0, *vp++, multipliers_3);
-			v1 = fold_vec(v1, *vp++, multipliers_3);
-			v2 = fold_vec(v2, *vp++, multipliers_3);
-			len -= 48;
-		}
-		v0 = fold_vec(v0, v1, multipliers_1);
-		v0 = fold_vec(v0, v2, multipliers_1);
-		p = (const u8 *)vp;
-	}
-	/* Reduce 128 to 32 bits using crc32 instructions. */
-	crc = __crc32d(0, vgetq_lane_u64(vreinterpretq_u64_u8(v0), 0));
-	crc = __crc32d(crc, vgetq_lane_u64(vreinterpretq_u64_u8(v0), 1));
-tail:
-	/* Finish up the remainder using crc32 instructions. */
-	if (len & 32) {
-		crc = __crc32d(crc, get_unaligned_le64(p + 0));
-		crc = __crc32d(crc, get_unaligned_le64(p + 8));
-		crc = __crc32d(crc, get_unaligned_le64(p + 16));
-		crc = __crc32d(crc, get_unaligned_le64(p + 24));
-		p += 32;
-	}
-	if (len & 16) {
-		crc = __crc32d(crc, get_unaligned_le64(p + 0));
-		crc = __crc32d(crc, get_unaligned_le64(p + 8));
-		p += 16;
-	}
-	if (len & 8) {
-		crc = __crc32d(crc, get_unaligned_le64(p));
-		p += 8;
-	}
-	if (len & 4) {
-		crc = __crc32w(crc, get_unaligned_le32(p));
-		p += 4;
-	}
-	if (len & 2) {
-		crc = __crc32h(crc, get_unaligned_le16(p));
-		p += 2;
-	}
-	if (len & 1)
-		crc = __crc32b(crc, *p);
-	return crc;
-}
-
-#undef SUFFIX
-#undef ATTRIBUTES
-#undef ENABLE_EOR3
diff --git a/vendor/core/vendor/libdeflate/lib/arm/matchfinder_impl.h b/vendor/core/vendor/libdeflate/lib/arm/matchfinder_impl.h
deleted file mode 100644
index 79c1dbc9..00000000
--- a/vendor/core/vendor/libdeflate/lib/arm/matchfinder_impl.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * arm/matchfinder_impl.h - ARM implementations of matchfinder functions
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_ARM_MATCHFINDER_IMPL_H
-#define LIB_ARM_MATCHFINDER_IMPL_H
-
-#include "cpu_features.h"
-
-#if HAVE_NEON_NATIVE
-static forceinline void
-matchfinder_init_neon(mf_pos_t *data, size_t size)
-{
-	int16x8_t *p = (int16x8_t *)data;
-	int16x8_t v = vdupq_n_s16(MATCHFINDER_INITVAL);
-
-	STATIC_ASSERT(MATCHFINDER_MEM_ALIGNMENT % sizeof(*p) == 0);
-	STATIC_ASSERT(MATCHFINDER_SIZE_ALIGNMENT % (4 * sizeof(*p)) == 0);
-	STATIC_ASSERT(sizeof(mf_pos_t) == 2);
-
-	do {
-		p[0] = v;
-		p[1] = v;
-		p[2] = v;
-		p[3] = v;
-		p += 4;
-		size -= 4 * sizeof(*p);
-	} while (size != 0);
-}
-#define matchfinder_init matchfinder_init_neon
-
-static forceinline void
-matchfinder_rebase_neon(mf_pos_t *data, size_t size)
-{
-	int16x8_t *p = (int16x8_t *)data;
-	int16x8_t v = vdupq_n_s16((u16)-MATCHFINDER_WINDOW_SIZE);
-
-	STATIC_ASSERT(MATCHFINDER_MEM_ALIGNMENT % sizeof(*p) == 0);
-	STATIC_ASSERT(MATCHFINDER_SIZE_ALIGNMENT % (4 * sizeof(*p)) == 0);
-	STATIC_ASSERT(sizeof(mf_pos_t) == 2);
-
-	do {
-		p[0] = vqaddq_s16(p[0], v);
-		p[1] = vqaddq_s16(p[1], v);
-		p[2] = vqaddq_s16(p[2], v);
-		p[3] = vqaddq_s16(p[3], v);
-		p += 4;
-		size -= 4 * sizeof(*p);
-	} while (size != 0);
-}
-#define matchfinder_rebase matchfinder_rebase_neon
-
-#endif /* HAVE_NEON_NATIVE */
-
-#endif /* LIB_ARM_MATCHFINDER_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/bt_matchfinder.h b/vendor/core/vendor/libdeflate/lib/bt_matchfinder.h
deleted file mode 100644
index b247d4bc..00000000
--- a/vendor/core/vendor/libdeflate/lib/bt_matchfinder.h
+++ /dev/null
@@ -1,342 +0,0 @@
-/*
- * bt_matchfinder.h - Lempel-Ziv matchfinding with a hash table of binary trees
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- *
- * ----------------------------------------------------------------------------
- *
- * This is a Binary Trees (bt) based matchfinder.
- *
- * The main data structure is a hash table where each hash bucket contains a
- * binary tree of sequences whose first 4 bytes share the same hash code.  Each
- * sequence is identified by its starting position in the input buffer.  Each
- * binary tree is always sorted such that each left child represents a sequence
- * lexicographically lesser than its parent and each right child represents a
- * sequence lexicographically greater than its parent.
- *
- * The algorithm processes the input buffer sequentially.  At each byte
- * position, the hash code of the first 4 bytes of the sequence beginning at
- * that position (the sequence being matched against) is computed.  This
- * identifies the hash bucket to use for that position.  Then, a new binary tree
- * node is created to represent the current sequence.  Then, in a single tree
- * traversal, the hash bucket's binary tree is searched for matches and is
- * re-rooted at the new node.
- *
- * Compared to the simpler algorithm that uses linked lists instead of binary
- * trees (see hc_matchfinder.h), the binary tree version gains more information
- * at each node visitation.  Ideally, the binary tree version will examine only
- * 'log(n)' nodes to find the same matches that the linked list version will
- * find by examining 'n' nodes.  In addition, the binary tree version can
- * examine fewer bytes at each node by taking advantage of the common prefixes
- * that result from the sort order, whereas the linked list version may have to
- * examine up to the full length of the match at each node.
- *
- * However, it is not always best to use the binary tree version.  It requires
- * nearly twice as much memory as the linked list version, and it takes time to
- * keep the binary trees sorted, even at positions where the compressor does not
- * need matches.  Generally, when doing fast compression on small buffers,
- * binary trees are the wrong approach.  They are best suited for thorough
- * compression and/or large buffers.
- *
- * ----------------------------------------------------------------------------
- */
-
-#ifndef LIB_BT_MATCHFINDER_H
-#define LIB_BT_MATCHFINDER_H
-
-#include "matchfinder_common.h"
-
-#define BT_MATCHFINDER_HASH3_ORDER 16
-#define BT_MATCHFINDER_HASH3_WAYS  2
-#define BT_MATCHFINDER_HASH4_ORDER 16
-
-#define BT_MATCHFINDER_TOTAL_HASH_SIZE		\
-	(((1UL << BT_MATCHFINDER_HASH3_ORDER) * BT_MATCHFINDER_HASH3_WAYS + \
-	  (1UL << BT_MATCHFINDER_HASH4_ORDER)) * sizeof(mf_pos_t))
-
-/* Representation of a match found by the bt_matchfinder  */
-struct lz_match {
-
-	/* The number of bytes matched.  */
-	u16 length;
-
-	/* The offset back from the current position that was matched.  */
-	u16 offset;
-};
-
-struct MATCHFINDER_ALIGNED bt_matchfinder {
-
-	/* The hash table for finding length 3 matches  */
-	mf_pos_t hash3_tab[1UL << BT_MATCHFINDER_HASH3_ORDER][BT_MATCHFINDER_HASH3_WAYS];
-
-	/* The hash table which contains the roots of the binary trees for
-	 * finding length 4+ matches  */
-	mf_pos_t hash4_tab[1UL << BT_MATCHFINDER_HASH4_ORDER];
-
-	/* The child node references for the binary trees.  The left and right
-	 * children of the node for the sequence with position 'pos' are
-	 * 'child_tab[pos * 2]' and 'child_tab[pos * 2 + 1]', respectively.  */
-	mf_pos_t child_tab[2UL * MATCHFINDER_WINDOW_SIZE];
-};
-
-/* Prepare the matchfinder for a new input buffer.  */
-static forceinline void
-bt_matchfinder_init(struct bt_matchfinder *mf)
-{
-	STATIC_ASSERT(BT_MATCHFINDER_TOTAL_HASH_SIZE %
-		      MATCHFINDER_SIZE_ALIGNMENT == 0);
-
-	matchfinder_init((mf_pos_t *)mf, BT_MATCHFINDER_TOTAL_HASH_SIZE);
-}
-
-static forceinline void
-bt_matchfinder_slide_window(struct bt_matchfinder *mf)
-{
-	STATIC_ASSERT(sizeof(*mf) % MATCHFINDER_SIZE_ALIGNMENT == 0);
-
-	matchfinder_rebase((mf_pos_t *)mf, sizeof(*mf));
-}
-
-static forceinline mf_pos_t *
-bt_left_child(struct bt_matchfinder *mf, s32 node)
-{
-	return &mf->child_tab[2 * (node & (MATCHFINDER_WINDOW_SIZE - 1)) + 0];
-}
-
-static forceinline mf_pos_t *
-bt_right_child(struct bt_matchfinder *mf, s32 node)
-{
-	return &mf->child_tab[2 * (node & (MATCHFINDER_WINDOW_SIZE - 1)) + 1];
-}
-
-/* The minimum permissible value of 'max_len' for bt_matchfinder_get_matches()
- * and bt_matchfinder_skip_byte().  There must be sufficiently many bytes
- * remaining to load a 32-bit integer from the *next* position.  */
-#define BT_MATCHFINDER_REQUIRED_NBYTES	5
-
-/* Advance the binary tree matchfinder by one byte, optionally recording
- * matches.  @record_matches should be a compile-time constant.  */
-static forceinline struct lz_match *
-bt_matchfinder_advance_one_byte(struct bt_matchfinder * const mf,
-				const u8 * const in_base,
-				const ptrdiff_t cur_pos,
-				const u32 max_len,
-				const u32 nice_len,
-				const u32 max_search_depth,
-				u32 * const next_hashes,
-				struct lz_match *lz_matchptr,
-				const bool record_matches)
-{
-	const u8 *in_next = in_base + cur_pos;
-	u32 depth_remaining = max_search_depth;
-	const s32 cutoff = cur_pos - MATCHFINDER_WINDOW_SIZE;
-	u32 next_hashseq;
-	u32 hash3;
-	u32 hash4;
-	s32 cur_node;
-#if BT_MATCHFINDER_HASH3_WAYS >= 2
-	s32 cur_node_2;
-#endif
-	const u8 *matchptr;
-	mf_pos_t *pending_lt_ptr, *pending_gt_ptr;
-	u32 best_lt_len, best_gt_len;
-	u32 len;
-	u32 best_len = 3;
-
-	STATIC_ASSERT(BT_MATCHFINDER_HASH3_WAYS >= 1 &&
-		      BT_MATCHFINDER_HASH3_WAYS <= 2);
-
-	next_hashseq = get_unaligned_le32(in_next + 1);
-
-	hash3 = next_hashes[0];
-	hash4 = next_hashes[1];
-
-	next_hashes[0] = lz_hash(next_hashseq & 0xFFFFFF, BT_MATCHFINDER_HASH3_ORDER);
-	next_hashes[1] = lz_hash(next_hashseq, BT_MATCHFINDER_HASH4_ORDER);
-	prefetchw(&mf->hash3_tab[next_hashes[0]]);
-	prefetchw(&mf->hash4_tab[next_hashes[1]]);
-
-	cur_node = mf->hash3_tab[hash3][0];
-	mf->hash3_tab[hash3][0] = cur_pos;
-#if BT_MATCHFINDER_HASH3_WAYS >= 2
-	cur_node_2 = mf->hash3_tab[hash3][1];
-	mf->hash3_tab[hash3][1] = cur_node;
-#endif
-	if (record_matches && cur_node > cutoff) {
-		u32 seq3 = load_u24_unaligned(in_next);
-		if (seq3 == load_u24_unaligned(&in_base[cur_node])) {
-			lz_matchptr->length = 3;
-			lz_matchptr->offset = in_next - &in_base[cur_node];
-			lz_matchptr++;
-		}
-	#if BT_MATCHFINDER_HASH3_WAYS >= 2
-		else if (cur_node_2 > cutoff &&
-			seq3 == load_u24_unaligned(&in_base[cur_node_2]))
-		{
-			lz_matchptr->length = 3;
-			lz_matchptr->offset = in_next - &in_base[cur_node_2];
-			lz_matchptr++;
-		}
-	#endif
-	}
-
-	cur_node = mf->hash4_tab[hash4];
-	mf->hash4_tab[hash4] = cur_pos;
-
-	pending_lt_ptr = bt_left_child(mf, cur_pos);
-	pending_gt_ptr = bt_right_child(mf, cur_pos);
-
-	if (cur_node <= cutoff) {
-		*pending_lt_ptr = MATCHFINDER_INITVAL;
-		*pending_gt_ptr = MATCHFINDER_INITVAL;
-		return lz_matchptr;
-	}
-
-	best_lt_len = 0;
-	best_gt_len = 0;
-	len = 0;
-
-	for (;;) {
-		matchptr = &in_base[cur_node];
-
-		if (matchptr[len] == in_next[len]) {
-			len = lz_extend(in_next, matchptr, len + 1, max_len);
-			if (!record_matches || len > best_len) {
-				if (record_matches) {
-					best_len = len;
-					lz_matchptr->length = len;
-					lz_matchptr->offset = in_next - matchptr;
-					lz_matchptr++;
-				}
-				if (len >= nice_len) {
-					*pending_lt_ptr = *bt_left_child(mf, cur_node);
-					*pending_gt_ptr = *bt_right_child(mf, cur_node);
-					return lz_matchptr;
-				}
-			}
-		}
-
-		if (matchptr[len] < in_next[len]) {
-			*pending_lt_ptr = cur_node;
-			pending_lt_ptr = bt_right_child(mf, cur_node);
-			cur_node = *pending_lt_ptr;
-			best_lt_len = len;
-			if (best_gt_len < len)
-				len = best_gt_len;
-		} else {
-			*pending_gt_ptr = cur_node;
-			pending_gt_ptr = bt_left_child(mf, cur_node);
-			cur_node = *pending_gt_ptr;
-			best_gt_len = len;
-			if (best_lt_len < len)
-				len = best_lt_len;
-		}
-
-		if (cur_node <= cutoff || !--depth_remaining) {
-			*pending_lt_ptr = MATCHFINDER_INITVAL;
-			*pending_gt_ptr = MATCHFINDER_INITVAL;
-			return lz_matchptr;
-		}
-	}
-}
-
-/*
- * Retrieve a list of matches with the current position.
- *
- * @mf
- *	The matchfinder structure.
- * @in_base
- *	Pointer to the next byte in the input buffer to process _at the last
- *	time bt_matchfinder_init() or bt_matchfinder_slide_window() was called_.
- * @cur_pos
- *	The current position in the input buffer relative to @in_base (the
- *	position of the sequence being matched against).
- * @max_len
- *	The maximum permissible match length at this position.  Must be >=
- *	BT_MATCHFINDER_REQUIRED_NBYTES.
- * @nice_len
- *	Stop searching if a match of at least this length is found.
- *	Must be <= @max_len.
- * @max_search_depth
- *	Limit on the number of potential matches to consider.  Must be >= 1.
- * @next_hashes
- *	The precomputed hash codes for the sequence beginning at @in_next.
- *	These will be used and then updated with the precomputed hashcodes for
- *	the sequence beginning at @in_next + 1.
- * @lz_matchptr
- *	An array in which this function will record the matches.  The recorded
- *	matches will be sorted by strictly increasing length and (non-strictly)
- *	increasing offset.  The maximum number of matches that may be found is
- *	'nice_len - 2'.
- *
- * The return value is a pointer to the next available slot in the @lz_matchptr
- * array.  (If no matches were found, this will be the same as @lz_matchptr.)
- */
-static forceinline struct lz_match *
-bt_matchfinder_get_matches(struct bt_matchfinder *mf,
-			   const u8 *in_base,
-			   ptrdiff_t cur_pos,
-			   u32 max_len,
-			   u32 nice_len,
-			   u32 max_search_depth,
-			   u32 next_hashes[2],
-			   struct lz_match *lz_matchptr)
-{
-	return bt_matchfinder_advance_one_byte(mf,
-					       in_base,
-					       cur_pos,
-					       max_len,
-					       nice_len,
-					       max_search_depth,
-					       next_hashes,
-					       lz_matchptr,
-					       true);
-}
-
-/*
- * Advance the matchfinder, but don't record any matches.
- *
- * This is very similar to bt_matchfinder_get_matches() because both functions
- * must do hashing and tree re-rooting.
- */
-static forceinline void
-bt_matchfinder_skip_byte(struct bt_matchfinder *mf,
-			 const u8 *in_base,
-			 ptrdiff_t cur_pos,
-			 u32 nice_len,
-			 u32 max_search_depth,
-			 u32 next_hashes[2])
-{
-	bt_matchfinder_advance_one_byte(mf,
-					in_base,
-					cur_pos,
-					nice_len,
-					nice_len,
-					max_search_depth,
-					next_hashes,
-					NULL,
-					false);
-}
-
-#endif /* LIB_BT_MATCHFINDER_H */
diff --git a/vendor/core/vendor/libdeflate/lib/cpu_features_common.h b/vendor/core/vendor/libdeflate/lib/cpu_features_common.h
deleted file mode 100644
index d0531d5c..00000000
--- a/vendor/core/vendor/libdeflate/lib/cpu_features_common.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * cpu_features_common.h - code shared by all lib/$arch/cpu_features.c
- *
- * Copyright 2020 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_CPU_FEATURES_COMMON_H
-#define LIB_CPU_FEATURES_COMMON_H
-
-#if defined(TEST_SUPPORT__DO_NOT_USE) && !defined(FREESTANDING)
-   /* for strdup() and strtok_r() */
-#  undef _ANSI_SOURCE
-#  ifndef __APPLE__
-#    undef _GNU_SOURCE
-#    define _GNU_SOURCE
-#  endif
-#  include <stdio.h>
-#  include <stdlib.h>
-#  include <string.h>
-#endif
-
-#include "lib_common.h"
-
-struct cpu_feature {
-	u32 bit;
-	const char *name;
-};
-
-#if defined(TEST_SUPPORT__DO_NOT_USE) && !defined(FREESTANDING)
-/* Disable any features that are listed in $LIBDEFLATE_DISABLE_CPU_FEATURES. */
-static inline void
-disable_cpu_features_for_testing(u32 *features,
-				 const struct cpu_feature *feature_table,
-				 size_t feature_table_length)
-{
-	char *env_value, *strbuf, *p, *saveptr = NULL;
-	size_t i;
-
-	env_value = getenv("LIBDEFLATE_DISABLE_CPU_FEATURES");
-	if (!env_value)
-		return;
-	strbuf = strdup(env_value);
-	if (!strbuf)
-		abort();
-	p = strtok_r(strbuf, ",", &saveptr);
-	while (p) {
-		for (i = 0; i < feature_table_length; i++) {
-			if (strcmp(p, feature_table[i].name) == 0) {
-				*features &= ~feature_table[i].bit;
-				break;
-			}
-		}
-		if (i == feature_table_length) {
-			fprintf(stderr,
-				"unrecognized feature in LIBDEFLATE_DISABLE_CPU_FEATURES: \"%s\"\n",
-				p);
-			abort();
-		}
-		p = strtok_r(NULL, ",", &saveptr);
-	}
-	free(strbuf);
-}
-#else /* TEST_SUPPORT__DO_NOT_USE */
-static inline void
-disable_cpu_features_for_testing(u32 *features,
-				 const struct cpu_feature *feature_table,
-				 size_t feature_table_length)
-{
-}
-#endif /* !TEST_SUPPORT__DO_NOT_USE */
-
-#endif /* LIB_CPU_FEATURES_COMMON_H */
diff --git a/vendor/core/vendor/libdeflate/lib/crc32.c b/vendor/core/vendor/libdeflate/lib/crc32.c
deleted file mode 100644
index a0ec0223..00000000
--- a/vendor/core/vendor/libdeflate/lib/crc32.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- * crc32.c - CRC-32 checksum algorithm for the gzip format
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-/*
- * High-level description of CRC
- * =============================
- *
- * Consider a bit sequence 'bits[1...len]'.  Interpret 'bits' as the "message"
- * polynomial M(x) with coefficients in GF(2) (the field of integers modulo 2),
- * where the coefficient of 'x^i' is 'bits[len - i]'.  Then, compute:
- *
- *			R(x) = M(x)*x^n mod G(x)
- *
- * where G(x) is a selected "generator" polynomial of degree 'n'.  The remainder
- * R(x) is a polynomial of max degree 'n - 1'.  The CRC of 'bits' is R(x)
- * interpreted as a bitstring of length 'n'.
- *
- * CRC used in gzip
- * ================
- *
- * In the gzip format (RFC 1952):
- *
- *	- The bitstring to checksum is formed from the bytes of the uncompressed
- *	  data by concatenating the bits from the bytes in order, proceeding
- *	  from the low-order bit to the high-order bit within each byte.
- *
- *	- The generator polynomial G(x) is: x^32 + x^26 + x^23 + x^22 + x^16 +
- *	  x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1.
- *	  Consequently, the CRC length is 32 bits ("CRC-32").
- *
- *	- The highest order 32 coefficients of M(x)*x^n are inverted.
- *
- *	- All 32 coefficients of R(x) are inverted.
- *
- * The two inversions cause added leading and trailing zero bits to affect the
- * resulting CRC, whereas with a regular CRC such bits would have no effect on
- * the CRC.
- *
- * Computation and optimizations
- * =============================
- *
- * We can compute R(x) through "long division", maintaining only 32 bits of
- * state at any given time.  Multiplication by 'x' can be implemented as
- * right-shifting by 1 (assuming the polynomial<=>bitstring mapping where the
- * highest order bit represents the coefficient of x^0), and both addition and
- * subtraction can be implemented as bitwise exclusive OR (since we are working
- * in GF(2)).  Here is an unoptimized implementation:
- *
- *	static u32 crc32_gzip(const u8 *p, size_t len)
- *	{
- *		u32 crc = 0;
- *		const u32 divisor = 0xEDB88320;
- *
- *		for (size_t i = 0; i < len * 8 + 32; i++) {
- *			int bit;
- *			u32 multiple;
- *
- *			if (i < len * 8)
- *				bit = (p[i / 8] >> (i % 8)) & 1;
- *			else
- *				bit = 0; // one of the 32 appended 0 bits
- *
- *			if (i < 32) // the first 32 bits are inverted
- *				bit ^= 1;
- *
- *			if (crc & 1)
- *				multiple = divisor;
- *			else
- *				multiple = 0;
- *
- *			crc >>= 1;
- *			crc |= (u32)bit << 31;
- *			crc ^= multiple;
- *		}
- *
- *		return ~crc;
- *	}
- *
- * In this implementation, the 32-bit integer 'crc' maintains the remainder of
- * the currently processed portion of the message (with 32 zero bits appended)
- * when divided by the generator polynomial.  'crc' is the representation of
- * R(x), and 'divisor' is the representation of G(x) excluding the x^32
- * coefficient.  For each bit to process, we multiply R(x) by 'x^1', then add
- * 'x^0' if the new bit is a 1.  If this causes R(x) to gain a nonzero x^32
- * term, then we subtract G(x) from R(x).
- *
- * We can speed this up by taking advantage of the fact that XOR is commutative
- * and associative, so the order in which we combine the inputs into 'crc' is
- * unimportant.  And since each message bit we add doesn't affect the choice of
- * 'multiple' until 32 bits later, we need not actually add each message bit
- * until that point:
- *
- *	static u32 crc32_gzip(const u8 *p, size_t len)
- *	{
- *		u32 crc = ~0;
- *		const u32 divisor = 0xEDB88320;
- *
- *		for (size_t i = 0; i < len * 8; i++) {
- *			int bit;
- *			u32 multiple;
- *
- *			bit = (p[i / 8] >> (i % 8)) & 1;
- *			crc ^= bit;
- *			if (crc & 1)
- *				multiple = divisor;
- *			else
- *				multiple = 0;
- *			crc >>= 1;
- *			crc ^= multiple;
- *		}
- *
- *		return ~crc;
- *	}
- *
- * With the above implementation we get the effect of 32 appended 0 bits for
- * free; they never affect the choice of a divisor, nor would they change the
- * value of 'crc' if they were to be actually XOR'ed in.  And by starting with a
- * remainder of all 1 bits, we get the effect of complementing the first 32
- * message bits.
- *
- * The next optimization is to process the input in multi-bit units.  Suppose
- * that we insert the next 'n' message bits into the remainder.  Then we get an
- * intermediate remainder of length '32 + n' bits, and the CRC of the extra 'n'
- * bits is the amount by which the low 32 bits of the remainder will change as a
- * result of cancelling out those 'n' bits.  Taking n=8 (one byte) and
- * precomputing a table containing the CRC of each possible byte, we get
- * crc32_slice1() defined below.
- *
- * As a further optimization, we could increase the multi-bit unit size to 16.
- * However, that is inefficient because the table size explodes from 256 entries
- * (1024 bytes) to 65536 entries (262144 bytes), which wastes memory and won't
- * fit in L1 cache on typical processors.
- *
- * However, we can actually process 4 bytes at a time using 4 different tables
- * with 256 entries each.  Logically, we form a 64-bit intermediate remainder
- * and cancel out the high 32 bits in 8-bit chunks.  Bits 32-39 are cancelled
- * out by the CRC of those bits, whereas bits 40-47 are be cancelled out by the
- * CRC of those bits with 8 zero bits appended, and so on.
- *
- * In crc32_slice8(), this method is extended to 8 bytes at a time.  The
- * intermediate remainder (which we never actually store explicitly) is 96 bits.
- *
- * On CPUs that support fast carryless multiplication, CRCs can be computed even
- * more quickly via "folding".  See e.g. the x86 PCLMUL implementations.
- */
-
-#include "lib_common.h"
-#include "crc32_multipliers.h"
-#include "crc32_tables.h"
-
-/* This is the default implementation.  It uses the slice-by-8 method. */
-static u32 MAYBE_UNUSED
-crc32_slice8(u32 crc, const u8 *p, size_t len)
-{
-	const u8 * const end = p + len;
-	const u8 *end64;
-
-	for (; ((uintptr_t)p & 7) && p != end; p++)
-		crc = (crc >> 8) ^ crc32_slice8_table[(u8)crc ^ *p];
-
-	end64 = p + ((end - p) & ~7);
-	for (; p != end64; p += 8) {
-		u32 v1 = le32_bswap(*(const u32 *)(p + 0));
-		u32 v2 = le32_bswap(*(const u32 *)(p + 4));
-
-		crc = crc32_slice8_table[0x700 + (u8)((crc ^ v1) >> 0)] ^
-		      crc32_slice8_table[0x600 + (u8)((crc ^ v1) >> 8)] ^
-		      crc32_slice8_table[0x500 + (u8)((crc ^ v1) >> 16)] ^
-		      crc32_slice8_table[0x400 + (u8)((crc ^ v1) >> 24)] ^
-		      crc32_slice8_table[0x300 + (u8)(v2 >> 0)] ^
-		      crc32_slice8_table[0x200 + (u8)(v2 >> 8)] ^
-		      crc32_slice8_table[0x100 + (u8)(v2 >> 16)] ^
-		      crc32_slice8_table[0x000 + (u8)(v2 >> 24)];
-	}
-
-	for (; p != end; p++)
-		crc = (crc >> 8) ^ crc32_slice8_table[(u8)crc ^ *p];
-
-	return crc;
-}
-
-/*
- * This is a more lightweight generic implementation, which can be used as a
- * subroutine by architecture-specific implementations to process small amounts
- * of unaligned data at the beginning and/or end of the buffer.
- */
-static forceinline u32 MAYBE_UNUSED
-crc32_slice1(u32 crc, const u8 *p, size_t len)
-{
-	size_t i;
-
-	for (i = 0; i < len; i++)
-		crc = (crc >> 8) ^ crc32_slice1_table[(u8)crc ^ p[i]];
-	return crc;
-}
-
-/* Include architecture-specific implementation(s) if available. */
-#undef DEFAULT_IMPL
-#undef arch_select_crc32_func
-typedef u32 (*crc32_func_t)(u32 crc, const u8 *p, size_t len);
-#if defined(ARCH_ARM32) || defined(ARCH_ARM64)
-#  include "arm/crc32_impl.h"
-#elif defined(ARCH_X86_32) || defined(ARCH_X86_64)
-#  include "x86/crc32_impl.h"
-#endif
-
-#ifndef DEFAULT_IMPL
-#  define DEFAULT_IMPL crc32_slice8
-#endif
-
-#ifdef arch_select_crc32_func
-static u32 dispatch_crc32(u32 crc, const u8 *p, size_t len);
-
-static volatile crc32_func_t crc32_impl = dispatch_crc32;
-
-/* Choose the best implementation at runtime. */
-static u32 dispatch_crc32(u32 crc, const u8 *p, size_t len)
-{
-	crc32_func_t f = arch_select_crc32_func();
-
-	if (f == NULL)
-		f = DEFAULT_IMPL;
-
-	crc32_impl = f;
-	return f(crc, p, len);
-}
-#else
-/* The best implementation is statically known, so call it directly. */
-#define crc32_impl DEFAULT_IMPL
-#endif
-
-LIBDEFLATEAPI u32
-libdeflate_crc32(u32 crc, const void *p, size_t len)
-{
-	if (p == NULL) /* Return initial value. */
-		return 0;
-	return ~crc32_impl(~crc, p, len);
-}
diff --git a/vendor/core/vendor/libdeflate/lib/crc32_multipliers.h b/vendor/core/vendor/libdeflate/lib/crc32_multipliers.h
deleted file mode 100644
index 9a08745e..00000000
--- a/vendor/core/vendor/libdeflate/lib/crc32_multipliers.h
+++ /dev/null
@@ -1,375 +0,0 @@
-/*
- * crc32_multipliers.h - constants for CRC-32 folding
- *
- * THIS FILE WAS GENERATED BY gen-crc32-consts.py.  DO NOT EDIT.
- */
-
-#define CRC32_X159_MODG 0xae689191 /* x^159 mod G(x) */
-#define CRC32_X95_MODG 0xccaa009e /* x^95 mod G(x) */
-
-#define CRC32_X287_MODG 0xf1da05aa /* x^287 mod G(x) */
-#define CRC32_X223_MODG 0x81256527 /* x^223 mod G(x) */
-
-#define CRC32_X415_MODG 0x3db1ecdc /* x^415 mod G(x) */
-#define CRC32_X351_MODG 0xaf449247 /* x^351 mod G(x) */
-
-#define CRC32_X543_MODG 0x8f352d95 /* x^543 mod G(x) */
-#define CRC32_X479_MODG 0x1d9513d7 /* x^479 mod G(x) */
-
-#define CRC32_X671_MODG 0x1c279815 /* x^671 mod G(x) */
-#define CRC32_X607_MODG 0xae0b5394 /* x^607 mod G(x) */
-
-#define CRC32_X799_MODG 0xdf068dc2 /* x^799 mod G(x) */
-#define CRC32_X735_MODG 0x57c54819 /* x^735 mod G(x) */
-
-#define CRC32_X927_MODG 0x31f8303f /* x^927 mod G(x) */
-#define CRC32_X863_MODG 0x0cbec0ed /* x^863 mod G(x) */
-
-#define CRC32_X1055_MODG 0x33fff533 /* x^1055 mod G(x) */
-#define CRC32_X991_MODG 0x910eeec1 /* x^991 mod G(x) */
-
-#define CRC32_X1183_MODG 0x26b70c3d /* x^1183 mod G(x) */
-#define CRC32_X1119_MODG 0x3f41287a /* x^1119 mod G(x) */
-
-#define CRC32_X1311_MODG 0xe3543be0 /* x^1311 mod G(x) */
-#define CRC32_X1247_MODG 0x9026d5b1 /* x^1247 mod G(x) */
-
-#define CRC32_X1439_MODG 0x5a1bb05d /* x^1439 mod G(x) */
-#define CRC32_X1375_MODG 0xd1df2327 /* x^1375 mod G(x) */
-
-#define CRC32_X1567_MODG 0x596c8d81 /* x^1567 mod G(x) */
-#define CRC32_X1503_MODG 0xf5e48c85 /* x^1503 mod G(x) */
-
-#define CRC32_X1695_MODG 0x682bdd4f /* x^1695 mod G(x) */
-#define CRC32_X1631_MODG 0x3c656ced /* x^1631 mod G(x) */
-
-#define CRC32_X1823_MODG 0x4a28bd43 /* x^1823 mod G(x) */
-#define CRC32_X1759_MODG 0xfe807bbd /* x^1759 mod G(x) */
-
-#define CRC32_X1951_MODG 0x0077f00d /* x^1951 mod G(x) */
-#define CRC32_X1887_MODG 0x1f0c2cdd /* x^1887 mod G(x) */
-
-#define CRC32_X2079_MODG 0xce3371cb /* x^2079 mod G(x) */
-#define CRC32_X2015_MODG 0xe95c1271 /* x^2015 mod G(x) */
-
-#define CRC32_X2207_MODG 0xa749e894 /* x^2207 mod G(x) */
-#define CRC32_X2143_MODG 0xb918a347 /* x^2143 mod G(x) */
-
-#define CRC32_X2335_MODG 0x2c538639 /* x^2335 mod G(x) */
-#define CRC32_X2271_MODG 0x71d54a59 /* x^2271 mod G(x) */
-
-#define CRC32_X2463_MODG 0x32b0733c /* x^2463 mod G(x) */
-#define CRC32_X2399_MODG 0xff6f2fc2 /* x^2399 mod G(x) */
-
-#define CRC32_X2591_MODG 0x0e9bd5cc /* x^2591 mod G(x) */
-#define CRC32_X2527_MODG 0xcec97417 /* x^2527 mod G(x) */
-
-#define CRC32_X2719_MODG 0x76278617 /* x^2719 mod G(x) */
-#define CRC32_X2655_MODG 0x1c63267b /* x^2655 mod G(x) */
-
-#define CRC32_X2847_MODG 0xc51b93e3 /* x^2847 mod G(x) */
-#define CRC32_X2783_MODG 0xf183c71b /* x^2783 mod G(x) */
-
-#define CRC32_X2975_MODG 0x7eaed122 /* x^2975 mod G(x) */
-#define CRC32_X2911_MODG 0x9b9bdbd0 /* x^2911 mod G(x) */
-
-#define CRC32_X3103_MODG 0x2ce423f1 /* x^3103 mod G(x) */
-#define CRC32_X3039_MODG 0xd31343ea /* x^3039 mod G(x) */
-
-#define CRC32_X3231_MODG 0x8b8d8645 /* x^3231 mod G(x) */
-#define CRC32_X3167_MODG 0x4470ac44 /* x^3167 mod G(x) */
-
-#define CRC32_X3359_MODG 0x4b700aa8 /* x^3359 mod G(x) */
-#define CRC32_X3295_MODG 0xeea395c4 /* x^3295 mod G(x) */
-
-#define CRC32_X3487_MODG 0xeff5e99d /* x^3487 mod G(x) */
-#define CRC32_X3423_MODG 0xf9d9c7ee /* x^3423 mod G(x) */
-
-#define CRC32_X3615_MODG 0xad0d2bb2 /* x^3615 mod G(x) */
-#define CRC32_X3551_MODG 0xcd669a40 /* x^3551 mod G(x) */
-
-#define CRC32_X3743_MODG 0x9fb66bd3 /* x^3743 mod G(x) */
-#define CRC32_X3679_MODG 0x6d40f445 /* x^3679 mod G(x) */
-
-#define CRC32_X3871_MODG 0xc2dcc467 /* x^3871 mod G(x) */
-#define CRC32_X3807_MODG 0x9ee62949 /* x^3807 mod G(x) */
-
-#define CRC32_X3999_MODG 0x398e2ff2 /* x^3999 mod G(x) */
-#define CRC32_X3935_MODG 0x145575d5 /* x^3935 mod G(x) */
-
-#define CRC32_X4127_MODG 0x1072db28 /* x^4127 mod G(x) */
-#define CRC32_X4063_MODG 0x0c30f51d /* x^4063 mod G(x) */
-
-#define CRC32_BARRETT_CONSTANT_1 0xb4e5b025f7011641ULL /* floor(x^95 / G(x)) */
-#define CRC32_BARRETT_CONSTANT_2 0x00000001db710641ULL /* G(x) */
-
-#define CRC32_NUM_CHUNKS 4
-#define CRC32_MIN_VARIABLE_CHUNK_LEN 128UL
-#define CRC32_MAX_VARIABLE_CHUNK_LEN 16384UL
-
-/* Multipliers for implementations that use a variable chunk length */
-static const u32 crc32_mults_for_chunklen[][CRC32_NUM_CHUNKS - 1] MAYBE_UNUSED = {
-	{ 0 /* unused row */ },
-	/* chunk_len=128 */
-	{ 0xd31343ea /* x^3039 mod G(x) */, 0xe95c1271 /* x^2015 mod G(x) */, 0x910eeec1 /* x^991 mod G(x) */, },
-	/* chunk_len=256 */
-	{ 0x1d6708a0 /* x^6111 mod G(x) */, 0x0c30f51d /* x^4063 mod G(x) */, 0xe95c1271 /* x^2015 mod G(x) */, },
-	/* chunk_len=384 */
-	{ 0xdb3839f3 /* x^9183 mod G(x) */, 0x1d6708a0 /* x^6111 mod G(x) */, 0xd31343ea /* x^3039 mod G(x) */, },
-	/* chunk_len=512 */
-	{ 0x1753ab84 /* x^12255 mod G(x) */, 0xbbf2f6d6 /* x^8159 mod G(x) */, 0x0c30f51d /* x^4063 mod G(x) */, },
-	/* chunk_len=640 */
-	{ 0x3796455c /* x^15327 mod G(x) */, 0xb8e0e4a8 /* x^10207 mod G(x) */, 0xc352f6de /* x^5087 mod G(x) */, },
-	/* chunk_len=768 */
-	{ 0x3954de39 /* x^18399 mod G(x) */, 0x1753ab84 /* x^12255 mod G(x) */, 0x1d6708a0 /* x^6111 mod G(x) */, },
-	/* chunk_len=896 */
-	{ 0x632d78c5 /* x^21471 mod G(x) */, 0x3fc33de4 /* x^14303 mod G(x) */, 0x9a1b53c8 /* x^7135 mod G(x) */, },
-	/* chunk_len=1024 */
-	{ 0xa0decef3 /* x^24543 mod G(x) */, 0x7b4aa8b7 /* x^16351 mod G(x) */, 0xbbf2f6d6 /* x^8159 mod G(x) */, },
-	/* chunk_len=1152 */
-	{ 0xe9c09bb0 /* x^27615 mod G(x) */, 0x3954de39 /* x^18399 mod G(x) */, 0xdb3839f3 /* x^9183 mod G(x) */, },
-	/* chunk_len=1280 */
-	{ 0xd51917a4 /* x^30687 mod G(x) */, 0xcae68461 /* x^20447 mod G(x) */, 0xb8e0e4a8 /* x^10207 mod G(x) */, },
-	/* chunk_len=1408 */
-	{ 0x154a8a62 /* x^33759 mod G(x) */, 0x41e7589c /* x^22495 mod G(x) */, 0x3e9a43cd /* x^11231 mod G(x) */, },
-	/* chunk_len=1536 */
-	{ 0xf196555d /* x^36831 mod G(x) */, 0xa0decef3 /* x^24543 mod G(x) */, 0x1753ab84 /* x^12255 mod G(x) */, },
-	/* chunk_len=1664 */
-	{ 0x8eec2999 /* x^39903 mod G(x) */, 0xefb0a128 /* x^26591 mod G(x) */, 0x6044fbb0 /* x^13279 mod G(x) */, },
-	/* chunk_len=1792 */
-	{ 0x27892abf /* x^42975 mod G(x) */, 0x48d72bb1 /* x^28639 mod G(x) */, 0x3fc33de4 /* x^14303 mod G(x) */, },
-	/* chunk_len=1920 */
-	{ 0x77bc2419 /* x^46047 mod G(x) */, 0xd51917a4 /* x^30687 mod G(x) */, 0x3796455c /* x^15327 mod G(x) */, },
-	/* chunk_len=2048 */
-	{ 0xcea114a5 /* x^49119 mod G(x) */, 0x68c0a2c5 /* x^32735 mod G(x) */, 0x7b4aa8b7 /* x^16351 mod G(x) */, },
-	/* chunk_len=2176 */
-	{ 0xa1077e85 /* x^52191 mod G(x) */, 0x188cc628 /* x^34783 mod G(x) */, 0x0c21f835 /* x^17375 mod G(x) */, },
-	/* chunk_len=2304 */
-	{ 0xc5ed75e1 /* x^55263 mod G(x) */, 0xf196555d /* x^36831 mod G(x) */, 0x3954de39 /* x^18399 mod G(x) */, },
-	/* chunk_len=2432 */
-	{ 0xca4fba3f /* x^58335 mod G(x) */, 0x0acfa26f /* x^38879 mod G(x) */, 0x6cb21510 /* x^19423 mod G(x) */, },
-	/* chunk_len=2560 */
-	{ 0xcf5bcdc4 /* x^61407 mod G(x) */, 0x4fae7fc0 /* x^40927 mod G(x) */, 0xcae68461 /* x^20447 mod G(x) */, },
-	/* chunk_len=2688 */
-	{ 0xf36b9d16 /* x^64479 mod G(x) */, 0x27892abf /* x^42975 mod G(x) */, 0x632d78c5 /* x^21471 mod G(x) */, },
-	/* chunk_len=2816 */
-	{ 0xf76fd988 /* x^67551 mod G(x) */, 0xed5c39b1 /* x^45023 mod G(x) */, 0x41e7589c /* x^22495 mod G(x) */, },
-	/* chunk_len=2944 */
-	{ 0x6c45d92e /* x^70623 mod G(x) */, 0xff809fcd /* x^47071 mod G(x) */, 0x0c46baec /* x^23519 mod G(x) */, },
-	/* chunk_len=3072 */
-	{ 0x6116b82b /* x^73695 mod G(x) */, 0xcea114a5 /* x^49119 mod G(x) */, 0xa0decef3 /* x^24543 mod G(x) */, },
-	/* chunk_len=3200 */
-	{ 0x4d9899bb /* x^76767 mod G(x) */, 0x9f9d8d9c /* x^51167 mod G(x) */, 0x53deb236 /* x^25567 mod G(x) */, },
-	/* chunk_len=3328 */
-	{ 0x3e7c93b9 /* x^79839 mod G(x) */, 0x6666b805 /* x^53215 mod G(x) */, 0xefb0a128 /* x^26591 mod G(x) */, },
-	/* chunk_len=3456 */
-	{ 0x388b20ac /* x^82911 mod G(x) */, 0xc5ed75e1 /* x^55263 mod G(x) */, 0xe9c09bb0 /* x^27615 mod G(x) */, },
-	/* chunk_len=3584 */
-	{ 0x0956d953 /* x^85983 mod G(x) */, 0x97fbdb14 /* x^57311 mod G(x) */, 0x48d72bb1 /* x^28639 mod G(x) */, },
-	/* chunk_len=3712 */
-	{ 0x55cb4dfe /* x^89055 mod G(x) */, 0x1b37c832 /* x^59359 mod G(x) */, 0xc07331b3 /* x^29663 mod G(x) */, },
-	/* chunk_len=3840 */
-	{ 0x52222fea /* x^92127 mod G(x) */, 0xcf5bcdc4 /* x^61407 mod G(x) */, 0xd51917a4 /* x^30687 mod G(x) */, },
-	/* chunk_len=3968 */
-	{ 0x0603989b /* x^95199 mod G(x) */, 0xb03c8112 /* x^63455 mod G(x) */, 0x5e04b9a5 /* x^31711 mod G(x) */, },
-	/* chunk_len=4096 */
-	{ 0x4470c029 /* x^98271 mod G(x) */, 0x2339d155 /* x^65503 mod G(x) */, 0x68c0a2c5 /* x^32735 mod G(x) */, },
-	/* chunk_len=4224 */
-	{ 0xb6f35093 /* x^101343 mod G(x) */, 0xf76fd988 /* x^67551 mod G(x) */, 0x154a8a62 /* x^33759 mod G(x) */, },
-	/* chunk_len=4352 */
-	{ 0xc46805ba /* x^104415 mod G(x) */, 0x416f9449 /* x^69599 mod G(x) */, 0x188cc628 /* x^34783 mod G(x) */, },
-	/* chunk_len=4480 */
-	{ 0xc3876592 /* x^107487 mod G(x) */, 0x4b809189 /* x^71647 mod G(x) */, 0xc35cf6e7 /* x^35807 mod G(x) */, },
-	/* chunk_len=4608 */
-	{ 0x5b0c98b9 /* x^110559 mod G(x) */, 0x6116b82b /* x^73695 mod G(x) */, 0xf196555d /* x^36831 mod G(x) */, },
-	/* chunk_len=4736 */
-	{ 0x30d13e5f /* x^113631 mod G(x) */, 0x4c5a315a /* x^75743 mod G(x) */, 0x8c224466 /* x^37855 mod G(x) */, },
-	/* chunk_len=4864 */
-	{ 0x54afca53 /* x^116703 mod G(x) */, 0xbccfa2c1 /* x^77791 mod G(x) */, 0x0acfa26f /* x^38879 mod G(x) */, },
-	/* chunk_len=4992 */
-	{ 0x93102436 /* x^119775 mod G(x) */, 0x3e7c93b9 /* x^79839 mod G(x) */, 0x8eec2999 /* x^39903 mod G(x) */, },
-	/* chunk_len=5120 */
-	{ 0xbd2655a8 /* x^122847 mod G(x) */, 0x3e116c9d /* x^81887 mod G(x) */, 0x4fae7fc0 /* x^40927 mod G(x) */, },
-	/* chunk_len=5248 */
-	{ 0x70cd7f26 /* x^125919 mod G(x) */, 0x408e57f2 /* x^83935 mod G(x) */, 0x1691be45 /* x^41951 mod G(x) */, },
-	/* chunk_len=5376 */
-	{ 0x2d546c53 /* x^128991 mod G(x) */, 0x0956d953 /* x^85983 mod G(x) */, 0x27892abf /* x^42975 mod G(x) */, },
-	/* chunk_len=5504 */
-	{ 0xb53410a8 /* x^132063 mod G(x) */, 0x42ebf0ad /* x^88031 mod G(x) */, 0x161f3c12 /* x^43999 mod G(x) */, },
-	/* chunk_len=5632 */
-	{ 0x67a93f75 /* x^135135 mod G(x) */, 0xcf3233e4 /* x^90079 mod G(x) */, 0xed5c39b1 /* x^45023 mod G(x) */, },
-	/* chunk_len=5760 */
-	{ 0x9830ac33 /* x^138207 mod G(x) */, 0x52222fea /* x^92127 mod G(x) */, 0x77bc2419 /* x^46047 mod G(x) */, },
-	/* chunk_len=5888 */
-	{ 0xb0b6fc3e /* x^141279 mod G(x) */, 0x2fde73f8 /* x^94175 mod G(x) */, 0xff809fcd /* x^47071 mod G(x) */, },
-	/* chunk_len=6016 */
-	{ 0x84170f16 /* x^144351 mod G(x) */, 0xced90d99 /* x^96223 mod G(x) */, 0x30de0f98 /* x^48095 mod G(x) */, },
-	/* chunk_len=6144 */
-	{ 0xd7017a0c /* x^147423 mod G(x) */, 0x4470c029 /* x^98271 mod G(x) */, 0xcea114a5 /* x^49119 mod G(x) */, },
-	/* chunk_len=6272 */
-	{ 0xadb25de6 /* x^150495 mod G(x) */, 0x84f40beb /* x^100319 mod G(x) */, 0x2b7e0e1b /* x^50143 mod G(x) */, },
-	/* chunk_len=6400 */
-	{ 0x8282fddc /* x^153567 mod G(x) */, 0xec855937 /* x^102367 mod G(x) */, 0x9f9d8d9c /* x^51167 mod G(x) */, },
-	/* chunk_len=6528 */
-	{ 0x46362bee /* x^156639 mod G(x) */, 0xc46805ba /* x^104415 mod G(x) */, 0xa1077e85 /* x^52191 mod G(x) */, },
-	/* chunk_len=6656 */
-	{ 0xb9077a01 /* x^159711 mod G(x) */, 0xdf7a24ac /* x^106463 mod G(x) */, 0x6666b805 /* x^53215 mod G(x) */, },
-	/* chunk_len=6784 */
-	{ 0xf51d9bc6 /* x^162783 mod G(x) */, 0x2b52dc39 /* x^108511 mod G(x) */, 0x7e774cf6 /* x^54239 mod G(x) */, },
-	/* chunk_len=6912 */
-	{ 0x4ca19a29 /* x^165855 mod G(x) */, 0x5b0c98b9 /* x^110559 mod G(x) */, 0xc5ed75e1 /* x^55263 mod G(x) */, },
-	/* chunk_len=7040 */
-	{ 0xdc0fc3fc /* x^168927 mod G(x) */, 0xb939fcdf /* x^112607 mod G(x) */, 0x3678fed2 /* x^56287 mod G(x) */, },
-	/* chunk_len=7168 */
-	{ 0x63c3d167 /* x^171999 mod G(x) */, 0x70f9947d /* x^114655 mod G(x) */, 0x97fbdb14 /* x^57311 mod G(x) */, },
-	/* chunk_len=7296 */
-	{ 0x5851d254 /* x^175071 mod G(x) */, 0x54afca53 /* x^116703 mod G(x) */, 0xca4fba3f /* x^58335 mod G(x) */, },
-	/* chunk_len=7424 */
-	{ 0xfeacf2a1 /* x^178143 mod G(x) */, 0x7a3c0a6a /* x^118751 mod G(x) */, 0x1b37c832 /* x^59359 mod G(x) */, },
-	/* chunk_len=7552 */
-	{ 0x93b7edc8 /* x^181215 mod G(x) */, 0x1fea4d2a /* x^120799 mod G(x) */, 0x58fa96ee /* x^60383 mod G(x) */, },
-	/* chunk_len=7680 */
-	{ 0x5539e44a /* x^184287 mod G(x) */, 0xbd2655a8 /* x^122847 mod G(x) */, 0xcf5bcdc4 /* x^61407 mod G(x) */, },
-	/* chunk_len=7808 */
-	{ 0xde32a3d2 /* x^187359 mod G(x) */, 0x4ff61aa1 /* x^124895 mod G(x) */, 0x6a6a3694 /* x^62431 mod G(x) */, },
-	/* chunk_len=7936 */
-	{ 0xf0baeeb6 /* x^190431 mod G(x) */, 0x7ae2f6f4 /* x^126943 mod G(x) */, 0xb03c8112 /* x^63455 mod G(x) */, },
-	/* chunk_len=8064 */
-	{ 0xbe15887f /* x^193503 mod G(x) */, 0x2d546c53 /* x^128991 mod G(x) */, 0xf36b9d16 /* x^64479 mod G(x) */, },
-	/* chunk_len=8192 */
-	{ 0x64f34a05 /* x^196575 mod G(x) */, 0xe0ee5efe /* x^131039 mod G(x) */, 0x2339d155 /* x^65503 mod G(x) */, },
-	/* chunk_len=8320 */
-	{ 0x1b6d1aea /* x^199647 mod G(x) */, 0xfeafb67c /* x^133087 mod G(x) */, 0x4fb001a8 /* x^66527 mod G(x) */, },
-	/* chunk_len=8448 */
-	{ 0x82adb0b8 /* x^202719 mod G(x) */, 0x67a93f75 /* x^135135 mod G(x) */, 0xf76fd988 /* x^67551 mod G(x) */, },
-	/* chunk_len=8576 */
-	{ 0x694587c7 /* x^205791 mod G(x) */, 0x3b34408b /* x^137183 mod G(x) */, 0xeccb2978 /* x^68575 mod G(x) */, },
-	/* chunk_len=8704 */
-	{ 0xd2fc57c3 /* x^208863 mod G(x) */, 0x07fcf8c6 /* x^139231 mod G(x) */, 0x416f9449 /* x^69599 mod G(x) */, },
-	/* chunk_len=8832 */
-	{ 0x9dd6837c /* x^211935 mod G(x) */, 0xb0b6fc3e /* x^141279 mod G(x) */, 0x6c45d92e /* x^70623 mod G(x) */, },
-	/* chunk_len=8960 */
-	{ 0x3a9d1f97 /* x^215007 mod G(x) */, 0xefd033b2 /* x^143327 mod G(x) */, 0x4b809189 /* x^71647 mod G(x) */, },
-	/* chunk_len=9088 */
-	{ 0x1eee1d2a /* x^218079 mod G(x) */, 0xf2a6e46e /* x^145375 mod G(x) */, 0x55b4c814 /* x^72671 mod G(x) */, },
-	/* chunk_len=9216 */
-	{ 0xb57c7728 /* x^221151 mod G(x) */, 0xd7017a0c /* x^147423 mod G(x) */, 0x6116b82b /* x^73695 mod G(x) */, },
-	/* chunk_len=9344 */
-	{ 0xf2fc5d61 /* x^224223 mod G(x) */, 0x242aac86 /* x^149471 mod G(x) */, 0x05245cf0 /* x^74719 mod G(x) */, },
-	/* chunk_len=9472 */
-	{ 0x26387824 /* x^227295 mod G(x) */, 0xc15c4ca5 /* x^151519 mod G(x) */, 0x4c5a315a /* x^75743 mod G(x) */, },
-	/* chunk_len=9600 */
-	{ 0x8c151e77 /* x^230367 mod G(x) */, 0x8282fddc /* x^153567 mod G(x) */, 0x4d9899bb /* x^76767 mod G(x) */, },
-	/* chunk_len=9728 */
-	{ 0x8ea1f680 /* x^233439 mod G(x) */, 0xf5ff6cdd /* x^155615 mod G(x) */, 0xbccfa2c1 /* x^77791 mod G(x) */, },
-	/* chunk_len=9856 */
-	{ 0xe8cf3d2a /* x^236511 mod G(x) */, 0x338b1fb1 /* x^157663 mod G(x) */, 0xeda61f70 /* x^78815 mod G(x) */, },
-	/* chunk_len=9984 */
-	{ 0x21f15b59 /* x^239583 mod G(x) */, 0xb9077a01 /* x^159711 mod G(x) */, 0x3e7c93b9 /* x^79839 mod G(x) */, },
-	/* chunk_len=10112 */
-	{ 0x6f68d64a /* x^242655 mod G(x) */, 0x901b0161 /* x^161759 mod G(x) */, 0xb9fd3537 /* x^80863 mod G(x) */, },
-	/* chunk_len=10240 */
-	{ 0x71b74d95 /* x^245727 mod G(x) */, 0xf5ddd5ad /* x^163807 mod G(x) */, 0x3e116c9d /* x^81887 mod G(x) */, },
-	/* chunk_len=10368 */
-	{ 0x4c2e7261 /* x^248799 mod G(x) */, 0x4ca19a29 /* x^165855 mod G(x) */, 0x388b20ac /* x^82911 mod G(x) */, },
-	/* chunk_len=10496 */
-	{ 0x8a2d38e8 /* x^251871 mod G(x) */, 0xd27ee0a1 /* x^167903 mod G(x) */, 0x408e57f2 /* x^83935 mod G(x) */, },
-	/* chunk_len=10624 */
-	{ 0x7e58ca17 /* x^254943 mod G(x) */, 0x69dfedd2 /* x^169951 mod G(x) */, 0x3a76805e /* x^84959 mod G(x) */, },
-	/* chunk_len=10752 */
-	{ 0xf997967f /* x^258015 mod G(x) */, 0x63c3d167 /* x^171999 mod G(x) */, 0x0956d953 /* x^85983 mod G(x) */, },
-	/* chunk_len=10880 */
-	{ 0x48215963 /* x^261087 mod G(x) */, 0x71e1dfe0 /* x^174047 mod G(x) */, 0x42a6d410 /* x^87007 mod G(x) */, },
-	/* chunk_len=11008 */
-	{ 0xa704b94c /* x^264159 mod G(x) */, 0x679f198a /* x^176095 mod G(x) */, 0x42ebf0ad /* x^88031 mod G(x) */, },
-	/* chunk_len=11136 */
-	{ 0x1d699056 /* x^267231 mod G(x) */, 0xfeacf2a1 /* x^178143 mod G(x) */, 0x55cb4dfe /* x^89055 mod G(x) */, },
-	/* chunk_len=11264 */
-	{ 0x6800bcc5 /* x^270303 mod G(x) */, 0x16024f15 /* x^180191 mod G(x) */, 0xcf3233e4 /* x^90079 mod G(x) */, },
-	/* chunk_len=11392 */
-	{ 0x2d48e4ca /* x^273375 mod G(x) */, 0xbe61582f /* x^182239 mod G(x) */, 0x46026283 /* x^91103 mod G(x) */, },
-	/* chunk_len=11520 */
-	{ 0x4c4c2b55 /* x^276447 mod G(x) */, 0x5539e44a /* x^184287 mod G(x) */, 0x52222fea /* x^92127 mod G(x) */, },
-	/* chunk_len=11648 */
-	{ 0xd8ce94cb /* x^279519 mod G(x) */, 0xbc613c26 /* x^186335 mod G(x) */, 0x33776b4b /* x^93151 mod G(x) */, },
-	/* chunk_len=11776 */
-	{ 0xd0b5a02b /* x^282591 mod G(x) */, 0x490d3cc6 /* x^188383 mod G(x) */, 0x2fde73f8 /* x^94175 mod G(x) */, },
-	/* chunk_len=11904 */
-	{ 0xa223f7ec /* x^285663 mod G(x) */, 0xf0baeeb6 /* x^190431 mod G(x) */, 0x0603989b /* x^95199 mod G(x) */, },
-	/* chunk_len=12032 */
-	{ 0x58de337a /* x^288735 mod G(x) */, 0x3bf3d597 /* x^192479 mod G(x) */, 0xced90d99 /* x^96223 mod G(x) */, },
-	/* chunk_len=12160 */
-	{ 0x37f5d8f4 /* x^291807 mod G(x) */, 0x4d5b699b /* x^194527 mod G(x) */, 0xd7262e5f /* x^97247 mod G(x) */, },
-	/* chunk_len=12288 */
-	{ 0xfa8a435d /* x^294879 mod G(x) */, 0x64f34a05 /* x^196575 mod G(x) */, 0x4470c029 /* x^98271 mod G(x) */, },
-	/* chunk_len=12416 */
-	{ 0x238709fe /* x^297951 mod G(x) */, 0x52e7458f /* x^198623 mod G(x) */, 0x9a174cd3 /* x^99295 mod G(x) */, },
-	/* chunk_len=12544 */
-	{ 0x9e1ba6f5 /* x^301023 mod G(x) */, 0xef0272f7 /* x^200671 mod G(x) */, 0x84f40beb /* x^100319 mod G(x) */, },
-	/* chunk_len=12672 */
-	{ 0xcd8b57fa /* x^304095 mod G(x) */, 0x82adb0b8 /* x^202719 mod G(x) */, 0xb6f35093 /* x^101343 mod G(x) */, },
-	/* chunk_len=12800 */
-	{ 0x0aed142f /* x^307167 mod G(x) */, 0xb1650290 /* x^204767 mod G(x) */, 0xec855937 /* x^102367 mod G(x) */, },
-	/* chunk_len=12928 */
-	{ 0xd1f064db /* x^310239 mod G(x) */, 0x6e7340d3 /* x^206815 mod G(x) */, 0x5c28cb52 /* x^103391 mod G(x) */, },
-	/* chunk_len=13056 */
-	{ 0x464ac895 /* x^313311 mod G(x) */, 0xd2fc57c3 /* x^208863 mod G(x) */, 0xc46805ba /* x^104415 mod G(x) */, },
-	/* chunk_len=13184 */
-	{ 0xa0e6beea /* x^316383 mod G(x) */, 0xcfeec3d0 /* x^210911 mod G(x) */, 0x0225d214 /* x^105439 mod G(x) */, },
-	/* chunk_len=13312 */
-	{ 0x78703ce0 /* x^319455 mod G(x) */, 0xc60f6075 /* x^212959 mod G(x) */, 0xdf7a24ac /* x^106463 mod G(x) */, },
-	/* chunk_len=13440 */
-	{ 0xfea48165 /* x^322527 mod G(x) */, 0x3a9d1f97 /* x^215007 mod G(x) */, 0xc3876592 /* x^107487 mod G(x) */, },
-	/* chunk_len=13568 */
-	{ 0xdb89b8db /* x^325599 mod G(x) */, 0xa6172211 /* x^217055 mod G(x) */, 0x2b52dc39 /* x^108511 mod G(x) */, },
-	/* chunk_len=13696 */
-	{ 0x7ca03731 /* x^328671 mod G(x) */, 0x1db42849 /* x^219103 mod G(x) */, 0xc5df246e /* x^109535 mod G(x) */, },
-	/* chunk_len=13824 */
-	{ 0x8801d0aa /* x^331743 mod G(x) */, 0xb57c7728 /* x^221151 mod G(x) */, 0x5b0c98b9 /* x^110559 mod G(x) */, },
-	/* chunk_len=13952 */
-	{ 0xf89cd7f0 /* x^334815 mod G(x) */, 0xcc396a0b /* x^223199 mod G(x) */, 0xdb799c51 /* x^111583 mod G(x) */, },
-	/* chunk_len=14080 */
-	{ 0x1611a808 /* x^337887 mod G(x) */, 0xaeae6105 /* x^225247 mod G(x) */, 0xb939fcdf /* x^112607 mod G(x) */, },
-	/* chunk_len=14208 */
-	{ 0xe3cdb888 /* x^340959 mod G(x) */, 0x26387824 /* x^227295 mod G(x) */, 0x30d13e5f /* x^113631 mod G(x) */, },
-	/* chunk_len=14336 */
-	{ 0x552a4cf6 /* x^344031 mod G(x) */, 0xee2d04bb /* x^229343 mod G(x) */, 0x70f9947d /* x^114655 mod G(x) */, },
-	/* chunk_len=14464 */
-	{ 0x85e248e9 /* x^347103 mod G(x) */, 0x0a79663f /* x^231391 mod G(x) */, 0x53339cf7 /* x^115679 mod G(x) */, },
-	/* chunk_len=14592 */
-	{ 0x1c61c3e9 /* x^350175 mod G(x) */, 0x8ea1f680 /* x^233439 mod G(x) */, 0x54afca53 /* x^116703 mod G(x) */, },
-	/* chunk_len=14720 */
-	{ 0xb14cfc2b /* x^353247 mod G(x) */, 0x2e073302 /* x^235487 mod G(x) */, 0x10897992 /* x^117727 mod G(x) */, },
-	/* chunk_len=14848 */
-	{ 0x6ec444cc /* x^356319 mod G(x) */, 0x9e819f13 /* x^237535 mod G(x) */, 0x7a3c0a6a /* x^118751 mod G(x) */, },
-	/* chunk_len=14976 */
-	{ 0xe2fa5f80 /* x^359391 mod G(x) */, 0x21f15b59 /* x^239583 mod G(x) */, 0x93102436 /* x^119775 mod G(x) */, },
-	/* chunk_len=15104 */
-	{ 0x6d33f4c6 /* x^362463 mod G(x) */, 0x31a27455 /* x^241631 mod G(x) */, 0x1fea4d2a /* x^120799 mod G(x) */, },
-	/* chunk_len=15232 */
-	{ 0xb6dec609 /* x^365535 mod G(x) */, 0x4d437056 /* x^243679 mod G(x) */, 0x42eb1e2a /* x^121823 mod G(x) */, },
-	/* chunk_len=15360 */
-	{ 0x1846c518 /* x^368607 mod G(x) */, 0x71b74d95 /* x^245727 mod G(x) */, 0xbd2655a8 /* x^122847 mod G(x) */, },
-	/* chunk_len=15488 */
-	{ 0x9f947f8a /* x^371679 mod G(x) */, 0x2b501619 /* x^247775 mod G(x) */, 0xa4924b0e /* x^123871 mod G(x) */, },
-	/* chunk_len=15616 */
-	{ 0xb7442f4d /* x^374751 mod G(x) */, 0xba30a5d8 /* x^249823 mod G(x) */, 0x4ff61aa1 /* x^124895 mod G(x) */, },
-	/* chunk_len=15744 */
-	{ 0xe2c93242 /* x^377823 mod G(x) */, 0x8a2d38e8 /* x^251871 mod G(x) */, 0x70cd7f26 /* x^125919 mod G(x) */, },
-	/* chunk_len=15872 */
-	{ 0xcd6863df /* x^380895 mod G(x) */, 0x78fd88dc /* x^253919 mod G(x) */, 0x7ae2f6f4 /* x^126943 mod G(x) */, },
-	/* chunk_len=16000 */
-	{ 0xd512001d /* x^383967 mod G(x) */, 0xe6612dff /* x^255967 mod G(x) */, 0x5c4d0ca9 /* x^127967 mod G(x) */, },
-	/* chunk_len=16128 */
-	{ 0x4e8d6b6c /* x^387039 mod G(x) */, 0xf997967f /* x^258015 mod G(x) */, 0x2d546c53 /* x^128991 mod G(x) */, },
-	/* chunk_len=16256 */
-	{ 0xfa653ba1 /* x^390111 mod G(x) */, 0xc99014d4 /* x^260063 mod G(x) */, 0xa0c9fd27 /* x^130015 mod G(x) */, },
-	/* chunk_len=16384 */
-	{ 0x49893408 /* x^393183 mod G(x) */, 0x29c2448b /* x^262111 mod G(x) */, 0xe0ee5efe /* x^131039 mod G(x) */, },
-};
-
-/* Multipliers for implementations that use a large fixed chunk length */
-#define CRC32_FIXED_CHUNK_LEN 32768UL
-#define CRC32_FIXED_CHUNK_MULT_1 0x29c2448b /* x^262111 mod G(x) */
-#define CRC32_FIXED_CHUNK_MULT_2 0x4b912f53 /* x^524255 mod G(x) */
-#define CRC32_FIXED_CHUNK_MULT_3 0x454c93be /* x^786399 mod G(x) */
diff --git a/vendor/core/vendor/libdeflate/lib/crc32_tables.h b/vendor/core/vendor/libdeflate/lib/crc32_tables.h
deleted file mode 100644
index d6aff733..00000000
--- a/vendor/core/vendor/libdeflate/lib/crc32_tables.h
+++ /dev/null
@@ -1,587 +0,0 @@
-/*
- * crc32_tables.h - data tables for CRC-32 computation
- *
- * THIS FILE WAS GENERATED BY gen-crc32-consts.py.  DO NOT EDIT.
- */
-
-static const u32 crc32_slice1_table[] MAYBE_UNUSED = {
-	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
-	0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
-	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
-	0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
-	0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
-	0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-	0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
-	0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
-	0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
-	0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
-	0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
-	0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-	0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
-	0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
-	0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
-	0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
-	0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
-	0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-	0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
-	0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
-	0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
-	0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
-	0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
-	0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-	0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
-	0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
-	0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
-	0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
-	0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
-	0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
-	0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
-	0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
-	0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
-	0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
-	0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-	0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
-	0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
-	0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
-	0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
-	0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
-	0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
-	0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
-	0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
-	0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
-	0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
-	0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-	0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
-	0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
-	0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
-	0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
-	0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
-	0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-	0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
-	0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
-	0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
-	0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
-	0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
-	0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
-	0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
-	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
-	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
-};
-
-static const u32 crc32_slice8_table[] MAYBE_UNUSED = {
-	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
-	0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
-	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
-	0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
-	0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
-	0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-	0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
-	0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
-	0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
-	0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
-	0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
-	0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-	0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
-	0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
-	0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
-	0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
-	0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
-	0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-	0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
-	0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
-	0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
-	0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
-	0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
-	0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-	0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
-	0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
-	0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
-	0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
-	0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
-	0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-	0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
-	0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
-	0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
-	0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
-	0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
-	0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-	0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
-	0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
-	0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
-	0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
-	0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
-	0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-	0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
-	0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
-	0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
-	0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
-	0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
-	0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-	0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
-	0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
-	0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
-	0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
-	0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
-	0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-	0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
-	0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
-	0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
-	0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
-	0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
-	0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-	0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
-	0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
-	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
-	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
-	0x00000000, 0x191b3141, 0x32366282, 0x2b2d53c3,
-	0x646cc504, 0x7d77f445, 0x565aa786, 0x4f4196c7,
-	0xc8d98a08, 0xd1c2bb49, 0xfaefe88a, 0xe3f4d9cb,
-	0xacb54f0c, 0xb5ae7e4d, 0x9e832d8e, 0x87981ccf,
-	0x4ac21251, 0x53d92310, 0x78f470d3, 0x61ef4192,
-	0x2eaed755, 0x37b5e614, 0x1c98b5d7, 0x05838496,
-	0x821b9859, 0x9b00a918, 0xb02dfadb, 0xa936cb9a,
-	0xe6775d5d, 0xff6c6c1c, 0xd4413fdf, 0xcd5a0e9e,
-	0x958424a2, 0x8c9f15e3, 0xa7b24620, 0xbea97761,
-	0xf1e8e1a6, 0xe8f3d0e7, 0xc3de8324, 0xdac5b265,
-	0x5d5daeaa, 0x44469feb, 0x6f6bcc28, 0x7670fd69,
-	0x39316bae, 0x202a5aef, 0x0b07092c, 0x121c386d,
-	0xdf4636f3, 0xc65d07b2, 0xed705471, 0xf46b6530,
-	0xbb2af3f7, 0xa231c2b6, 0x891c9175, 0x9007a034,
-	0x179fbcfb, 0x0e848dba, 0x25a9de79, 0x3cb2ef38,
-	0x73f379ff, 0x6ae848be, 0x41c51b7d, 0x58de2a3c,
-	0xf0794f05, 0xe9627e44, 0xc24f2d87, 0xdb541cc6,
-	0x94158a01, 0x8d0ebb40, 0xa623e883, 0xbf38d9c2,
-	0x38a0c50d, 0x21bbf44c, 0x0a96a78f, 0x138d96ce,
-	0x5ccc0009, 0x45d73148, 0x6efa628b, 0x77e153ca,
-	0xbabb5d54, 0xa3a06c15, 0x888d3fd6, 0x91960e97,
-	0xded79850, 0xc7cca911, 0xece1fad2, 0xf5facb93,
-	0x7262d75c, 0x6b79e61d, 0x4054b5de, 0x594f849f,
-	0x160e1258, 0x0f152319, 0x243870da, 0x3d23419b,
-	0x65fd6ba7, 0x7ce65ae6, 0x57cb0925, 0x4ed03864,
-	0x0191aea3, 0x188a9fe2, 0x33a7cc21, 0x2abcfd60,
-	0xad24e1af, 0xb43fd0ee, 0x9f12832d, 0x8609b26c,
-	0xc94824ab, 0xd05315ea, 0xfb7e4629, 0xe2657768,
-	0x2f3f79f6, 0x362448b7, 0x1d091b74, 0x04122a35,
-	0x4b53bcf2, 0x52488db3, 0x7965de70, 0x607eef31,
-	0xe7e6f3fe, 0xfefdc2bf, 0xd5d0917c, 0xcccba03d,
-	0x838a36fa, 0x9a9107bb, 0xb1bc5478, 0xa8a76539,
-	0x3b83984b, 0x2298a90a, 0x09b5fac9, 0x10aecb88,
-	0x5fef5d4f, 0x46f46c0e, 0x6dd93fcd, 0x74c20e8c,
-	0xf35a1243, 0xea412302, 0xc16c70c1, 0xd8774180,
-	0x9736d747, 0x8e2de606, 0xa500b5c5, 0xbc1b8484,
-	0x71418a1a, 0x685abb5b, 0x4377e898, 0x5a6cd9d9,
-	0x152d4f1e, 0x0c367e5f, 0x271b2d9c, 0x3e001cdd,
-	0xb9980012, 0xa0833153, 0x8bae6290, 0x92b553d1,
-	0xddf4c516, 0xc4eff457, 0xefc2a794, 0xf6d996d5,
-	0xae07bce9, 0xb71c8da8, 0x9c31de6b, 0x852aef2a,
-	0xca6b79ed, 0xd37048ac, 0xf85d1b6f, 0xe1462a2e,
-	0x66de36e1, 0x7fc507a0, 0x54e85463, 0x4df36522,
-	0x02b2f3e5, 0x1ba9c2a4, 0x30849167, 0x299fa026,
-	0xe4c5aeb8, 0xfdde9ff9, 0xd6f3cc3a, 0xcfe8fd7b,
-	0x80a96bbc, 0x99b25afd, 0xb29f093e, 0xab84387f,
-	0x2c1c24b0, 0x350715f1, 0x1e2a4632, 0x07317773,
-	0x4870e1b4, 0x516bd0f5, 0x7a468336, 0x635db277,
-	0xcbfad74e, 0xd2e1e60f, 0xf9ccb5cc, 0xe0d7848d,
-	0xaf96124a, 0xb68d230b, 0x9da070c8, 0x84bb4189,
-	0x03235d46, 0x1a386c07, 0x31153fc4, 0x280e0e85,
-	0x674f9842, 0x7e54a903, 0x5579fac0, 0x4c62cb81,
-	0x8138c51f, 0x9823f45e, 0xb30ea79d, 0xaa1596dc,
-	0xe554001b, 0xfc4f315a, 0xd7626299, 0xce7953d8,
-	0x49e14f17, 0x50fa7e56, 0x7bd72d95, 0x62cc1cd4,
-	0x2d8d8a13, 0x3496bb52, 0x1fbbe891, 0x06a0d9d0,
-	0x5e7ef3ec, 0x4765c2ad, 0x6c48916e, 0x7553a02f,
-	0x3a1236e8, 0x230907a9, 0x0824546a, 0x113f652b,
-	0x96a779e4, 0x8fbc48a5, 0xa4911b66, 0xbd8a2a27,
-	0xf2cbbce0, 0xebd08da1, 0xc0fdde62, 0xd9e6ef23,
-	0x14bce1bd, 0x0da7d0fc, 0x268a833f, 0x3f91b27e,
-	0x70d024b9, 0x69cb15f8, 0x42e6463b, 0x5bfd777a,
-	0xdc656bb5, 0xc57e5af4, 0xee530937, 0xf7483876,
-	0xb809aeb1, 0xa1129ff0, 0x8a3fcc33, 0x9324fd72,
-	0x00000000, 0x01c26a37, 0x0384d46e, 0x0246be59,
-	0x0709a8dc, 0x06cbc2eb, 0x048d7cb2, 0x054f1685,
-	0x0e1351b8, 0x0fd13b8f, 0x0d9785d6, 0x0c55efe1,
-	0x091af964, 0x08d89353, 0x0a9e2d0a, 0x0b5c473d,
-	0x1c26a370, 0x1de4c947, 0x1fa2771e, 0x1e601d29,
-	0x1b2f0bac, 0x1aed619b, 0x18abdfc2, 0x1969b5f5,
-	0x1235f2c8, 0x13f798ff, 0x11b126a6, 0x10734c91,
-	0x153c5a14, 0x14fe3023, 0x16b88e7a, 0x177ae44d,
-	0x384d46e0, 0x398f2cd7, 0x3bc9928e, 0x3a0bf8b9,
-	0x3f44ee3c, 0x3e86840b, 0x3cc03a52, 0x3d025065,
-	0x365e1758, 0x379c7d6f, 0x35dac336, 0x3418a901,
-	0x3157bf84, 0x3095d5b3, 0x32d36bea, 0x331101dd,
-	0x246be590, 0x25a98fa7, 0x27ef31fe, 0x262d5bc9,
-	0x23624d4c, 0x22a0277b, 0x20e69922, 0x2124f315,
-	0x2a78b428, 0x2bbade1f, 0x29fc6046, 0x283e0a71,
-	0x2d711cf4, 0x2cb376c3, 0x2ef5c89a, 0x2f37a2ad,
-	0x709a8dc0, 0x7158e7f7, 0x731e59ae, 0x72dc3399,
-	0x7793251c, 0x76514f2b, 0x7417f172, 0x75d59b45,
-	0x7e89dc78, 0x7f4bb64f, 0x7d0d0816, 0x7ccf6221,
-	0x798074a4, 0x78421e93, 0x7a04a0ca, 0x7bc6cafd,
-	0x6cbc2eb0, 0x6d7e4487, 0x6f38fade, 0x6efa90e9,
-	0x6bb5866c, 0x6a77ec5b, 0x68315202, 0x69f33835,
-	0x62af7f08, 0x636d153f, 0x612bab66, 0x60e9c151,
-	0x65a6d7d4, 0x6464bde3, 0x662203ba, 0x67e0698d,
-	0x48d7cb20, 0x4915a117, 0x4b531f4e, 0x4a917579,
-	0x4fde63fc, 0x4e1c09cb, 0x4c5ab792, 0x4d98dda5,
-	0x46c49a98, 0x4706f0af, 0x45404ef6, 0x448224c1,
-	0x41cd3244, 0x400f5873, 0x4249e62a, 0x438b8c1d,
-	0x54f16850, 0x55330267, 0x5775bc3e, 0x56b7d609,
-	0x53f8c08c, 0x523aaabb, 0x507c14e2, 0x51be7ed5,
-	0x5ae239e8, 0x5b2053df, 0x5966ed86, 0x58a487b1,
-	0x5deb9134, 0x5c29fb03, 0x5e6f455a, 0x5fad2f6d,
-	0xe1351b80, 0xe0f771b7, 0xe2b1cfee, 0xe373a5d9,
-	0xe63cb35c, 0xe7fed96b, 0xe5b86732, 0xe47a0d05,
-	0xef264a38, 0xeee4200f, 0xeca29e56, 0xed60f461,
-	0xe82fe2e4, 0xe9ed88d3, 0xebab368a, 0xea695cbd,
-	0xfd13b8f0, 0xfcd1d2c7, 0xfe976c9e, 0xff5506a9,
-	0xfa1a102c, 0xfbd87a1b, 0xf99ec442, 0xf85cae75,
-	0xf300e948, 0xf2c2837f, 0xf0843d26, 0xf1465711,
-	0xf4094194, 0xf5cb2ba3, 0xf78d95fa, 0xf64fffcd,
-	0xd9785d60, 0xd8ba3757, 0xdafc890e, 0xdb3ee339,
-	0xde71f5bc, 0xdfb39f8b, 0xddf521d2, 0xdc374be5,
-	0xd76b0cd8, 0xd6a966ef, 0xd4efd8b6, 0xd52db281,
-	0xd062a404, 0xd1a0ce33, 0xd3e6706a, 0xd2241a5d,
-	0xc55efe10, 0xc49c9427, 0xc6da2a7e, 0xc7184049,
-	0xc25756cc, 0xc3953cfb, 0xc1d382a2, 0xc011e895,
-	0xcb4dafa8, 0xca8fc59f, 0xc8c97bc6, 0xc90b11f1,
-	0xcc440774, 0xcd866d43, 0xcfc0d31a, 0xce02b92d,
-	0x91af9640, 0x906dfc77, 0x922b422e, 0x93e92819,
-	0x96a63e9c, 0x976454ab, 0x9522eaf2, 0x94e080c5,
-	0x9fbcc7f8, 0x9e7eadcf, 0x9c381396, 0x9dfa79a1,
-	0x98b56f24, 0x99770513, 0x9b31bb4a, 0x9af3d17d,
-	0x8d893530, 0x8c4b5f07, 0x8e0de15e, 0x8fcf8b69,
-	0x8a809dec, 0x8b42f7db, 0x89044982, 0x88c623b5,
-	0x839a6488, 0x82580ebf, 0x801eb0e6, 0x81dcdad1,
-	0x8493cc54, 0x8551a663, 0x8717183a, 0x86d5720d,
-	0xa9e2d0a0, 0xa820ba97, 0xaa6604ce, 0xaba46ef9,
-	0xaeeb787c, 0xaf29124b, 0xad6fac12, 0xacadc625,
-	0xa7f18118, 0xa633eb2f, 0xa4755576, 0xa5b73f41,
-	0xa0f829c4, 0xa13a43f3, 0xa37cfdaa, 0xa2be979d,
-	0xb5c473d0, 0xb40619e7, 0xb640a7be, 0xb782cd89,
-	0xb2cddb0c, 0xb30fb13b, 0xb1490f62, 0xb08b6555,
-	0xbbd72268, 0xba15485f, 0xb853f606, 0xb9919c31,
-	0xbcde8ab4, 0xbd1ce083, 0xbf5a5eda, 0xbe9834ed,
-	0x00000000, 0xb8bc6765, 0xaa09c88b, 0x12b5afee,
-	0x8f629757, 0x37def032, 0x256b5fdc, 0x9dd738b9,
-	0xc5b428ef, 0x7d084f8a, 0x6fbde064, 0xd7018701,
-	0x4ad6bfb8, 0xf26ad8dd, 0xe0df7733, 0x58631056,
-	0x5019579f, 0xe8a530fa, 0xfa109f14, 0x42acf871,
-	0xdf7bc0c8, 0x67c7a7ad, 0x75720843, 0xcdce6f26,
-	0x95ad7f70, 0x2d111815, 0x3fa4b7fb, 0x8718d09e,
-	0x1acfe827, 0xa2738f42, 0xb0c620ac, 0x087a47c9,
-	0xa032af3e, 0x188ec85b, 0x0a3b67b5, 0xb28700d0,
-	0x2f503869, 0x97ec5f0c, 0x8559f0e2, 0x3de59787,
-	0x658687d1, 0xdd3ae0b4, 0xcf8f4f5a, 0x7733283f,
-	0xeae41086, 0x525877e3, 0x40edd80d, 0xf851bf68,
-	0xf02bf8a1, 0x48979fc4, 0x5a22302a, 0xe29e574f,
-	0x7f496ff6, 0xc7f50893, 0xd540a77d, 0x6dfcc018,
-	0x359fd04e, 0x8d23b72b, 0x9f9618c5, 0x272a7fa0,
-	0xbafd4719, 0x0241207c, 0x10f48f92, 0xa848e8f7,
-	0x9b14583d, 0x23a83f58, 0x311d90b6, 0x89a1f7d3,
-	0x1476cf6a, 0xaccaa80f, 0xbe7f07e1, 0x06c36084,
-	0x5ea070d2, 0xe61c17b7, 0xf4a9b859, 0x4c15df3c,
-	0xd1c2e785, 0x697e80e0, 0x7bcb2f0e, 0xc377486b,
-	0xcb0d0fa2, 0x73b168c7, 0x6104c729, 0xd9b8a04c,
-	0x446f98f5, 0xfcd3ff90, 0xee66507e, 0x56da371b,
-	0x0eb9274d, 0xb6054028, 0xa4b0efc6, 0x1c0c88a3,
-	0x81dbb01a, 0x3967d77f, 0x2bd27891, 0x936e1ff4,
-	0x3b26f703, 0x839a9066, 0x912f3f88, 0x299358ed,
-	0xb4446054, 0x0cf80731, 0x1e4da8df, 0xa6f1cfba,
-	0xfe92dfec, 0x462eb889, 0x549b1767, 0xec277002,
-	0x71f048bb, 0xc94c2fde, 0xdbf98030, 0x6345e755,
-	0x6b3fa09c, 0xd383c7f9, 0xc1366817, 0x798a0f72,
-	0xe45d37cb, 0x5ce150ae, 0x4e54ff40, 0xf6e89825,
-	0xae8b8873, 0x1637ef16, 0x048240f8, 0xbc3e279d,
-	0x21e91f24, 0x99557841, 0x8be0d7af, 0x335cb0ca,
-	0xed59b63b, 0x55e5d15e, 0x47507eb0, 0xffec19d5,
-	0x623b216c, 0xda874609, 0xc832e9e7, 0x708e8e82,
-	0x28ed9ed4, 0x9051f9b1, 0x82e4565f, 0x3a58313a,
-	0xa78f0983, 0x1f336ee6, 0x0d86c108, 0xb53aa66d,
-	0xbd40e1a4, 0x05fc86c1, 0x1749292f, 0xaff54e4a,
-	0x322276f3, 0x8a9e1196, 0x982bbe78, 0x2097d91d,
-	0x78f4c94b, 0xc048ae2e, 0xd2fd01c0, 0x6a4166a5,
-	0xf7965e1c, 0x4f2a3979, 0x5d9f9697, 0xe523f1f2,
-	0x4d6b1905, 0xf5d77e60, 0xe762d18e, 0x5fdeb6eb,
-	0xc2098e52, 0x7ab5e937, 0x680046d9, 0xd0bc21bc,
-	0x88df31ea, 0x3063568f, 0x22d6f961, 0x9a6a9e04,
-	0x07bda6bd, 0xbf01c1d8, 0xadb46e36, 0x15080953,
-	0x1d724e9a, 0xa5ce29ff, 0xb77b8611, 0x0fc7e174,
-	0x9210d9cd, 0x2aacbea8, 0x38191146, 0x80a57623,
-	0xd8c66675, 0x607a0110, 0x72cfaefe, 0xca73c99b,
-	0x57a4f122, 0xef189647, 0xfdad39a9, 0x45115ecc,
-	0x764dee06, 0xcef18963, 0xdc44268d, 0x64f841e8,
-	0xf92f7951, 0x41931e34, 0x5326b1da, 0xeb9ad6bf,
-	0xb3f9c6e9, 0x0b45a18c, 0x19f00e62, 0xa14c6907,
-	0x3c9b51be, 0x842736db, 0x96929935, 0x2e2efe50,
-	0x2654b999, 0x9ee8defc, 0x8c5d7112, 0x34e11677,
-	0xa9362ece, 0x118a49ab, 0x033fe645, 0xbb838120,
-	0xe3e09176, 0x5b5cf613, 0x49e959fd, 0xf1553e98,
-	0x6c820621, 0xd43e6144, 0xc68bceaa, 0x7e37a9cf,
-	0xd67f4138, 0x6ec3265d, 0x7c7689b3, 0xc4caeed6,
-	0x591dd66f, 0xe1a1b10a, 0xf3141ee4, 0x4ba87981,
-	0x13cb69d7, 0xab770eb2, 0xb9c2a15c, 0x017ec639,
-	0x9ca9fe80, 0x241599e5, 0x36a0360b, 0x8e1c516e,
-	0x866616a7, 0x3eda71c2, 0x2c6fde2c, 0x94d3b949,
-	0x090481f0, 0xb1b8e695, 0xa30d497b, 0x1bb12e1e,
-	0x43d23e48, 0xfb6e592d, 0xe9dbf6c3, 0x516791a6,
-	0xccb0a91f, 0x740cce7a, 0x66b96194, 0xde0506f1,
-	0x00000000, 0x3d6029b0, 0x7ac05360, 0x47a07ad0,
-	0xf580a6c0, 0xc8e08f70, 0x8f40f5a0, 0xb220dc10,
-	0x30704bc1, 0x0d106271, 0x4ab018a1, 0x77d03111,
-	0xc5f0ed01, 0xf890c4b1, 0xbf30be61, 0x825097d1,
-	0x60e09782, 0x5d80be32, 0x1a20c4e2, 0x2740ed52,
-	0x95603142, 0xa80018f2, 0xefa06222, 0xd2c04b92,
-	0x5090dc43, 0x6df0f5f3, 0x2a508f23, 0x1730a693,
-	0xa5107a83, 0x98705333, 0xdfd029e3, 0xe2b00053,
-	0xc1c12f04, 0xfca106b4, 0xbb017c64, 0x866155d4,
-	0x344189c4, 0x0921a074, 0x4e81daa4, 0x73e1f314,
-	0xf1b164c5, 0xccd14d75, 0x8b7137a5, 0xb6111e15,
-	0x0431c205, 0x3951ebb5, 0x7ef19165, 0x4391b8d5,
-	0xa121b886, 0x9c419136, 0xdbe1ebe6, 0xe681c256,
-	0x54a11e46, 0x69c137f6, 0x2e614d26, 0x13016496,
-	0x9151f347, 0xac31daf7, 0xeb91a027, 0xd6f18997,
-	0x64d15587, 0x59b17c37, 0x1e1106e7, 0x23712f57,
-	0x58f35849, 0x659371f9, 0x22330b29, 0x1f532299,
-	0xad73fe89, 0x9013d739, 0xd7b3ade9, 0xead38459,
-	0x68831388, 0x55e33a38, 0x124340e8, 0x2f236958,
-	0x9d03b548, 0xa0639cf8, 0xe7c3e628, 0xdaa3cf98,
-	0x3813cfcb, 0x0573e67b, 0x42d39cab, 0x7fb3b51b,
-	0xcd93690b, 0xf0f340bb, 0xb7533a6b, 0x8a3313db,
-	0x0863840a, 0x3503adba, 0x72a3d76a, 0x4fc3feda,
-	0xfde322ca, 0xc0830b7a, 0x872371aa, 0xba43581a,
-	0x9932774d, 0xa4525efd, 0xe3f2242d, 0xde920d9d,
-	0x6cb2d18d, 0x51d2f83d, 0x167282ed, 0x2b12ab5d,
-	0xa9423c8c, 0x9422153c, 0xd3826fec, 0xeee2465c,
-	0x5cc29a4c, 0x61a2b3fc, 0x2602c92c, 0x1b62e09c,
-	0xf9d2e0cf, 0xc4b2c97f, 0x8312b3af, 0xbe729a1f,
-	0x0c52460f, 0x31326fbf, 0x7692156f, 0x4bf23cdf,
-	0xc9a2ab0e, 0xf4c282be, 0xb362f86e, 0x8e02d1de,
-	0x3c220dce, 0x0142247e, 0x46e25eae, 0x7b82771e,
-	0xb1e6b092, 0x8c869922, 0xcb26e3f2, 0xf646ca42,
-	0x44661652, 0x79063fe2, 0x3ea64532, 0x03c66c82,
-	0x8196fb53, 0xbcf6d2e3, 0xfb56a833, 0xc6368183,
-	0x74165d93, 0x49767423, 0x0ed60ef3, 0x33b62743,
-	0xd1062710, 0xec660ea0, 0xabc67470, 0x96a65dc0,
-	0x248681d0, 0x19e6a860, 0x5e46d2b0, 0x6326fb00,
-	0xe1766cd1, 0xdc164561, 0x9bb63fb1, 0xa6d61601,
-	0x14f6ca11, 0x2996e3a1, 0x6e369971, 0x5356b0c1,
-	0x70279f96, 0x4d47b626, 0x0ae7ccf6, 0x3787e546,
-	0x85a73956, 0xb8c710e6, 0xff676a36, 0xc2074386,
-	0x4057d457, 0x7d37fde7, 0x3a978737, 0x07f7ae87,
-	0xb5d77297, 0x88b75b27, 0xcf1721f7, 0xf2770847,
-	0x10c70814, 0x2da721a4, 0x6a075b74, 0x576772c4,
-	0xe547aed4, 0xd8278764, 0x9f87fdb4, 0xa2e7d404,
-	0x20b743d5, 0x1dd76a65, 0x5a7710b5, 0x67173905,
-	0xd537e515, 0xe857cca5, 0xaff7b675, 0x92979fc5,
-	0xe915e8db, 0xd475c16b, 0x93d5bbbb, 0xaeb5920b,
-	0x1c954e1b, 0x21f567ab, 0x66551d7b, 0x5b3534cb,
-	0xd965a31a, 0xe4058aaa, 0xa3a5f07a, 0x9ec5d9ca,
-	0x2ce505da, 0x11852c6a, 0x562556ba, 0x6b457f0a,
-	0x89f57f59, 0xb49556e9, 0xf3352c39, 0xce550589,
-	0x7c75d999, 0x4115f029, 0x06b58af9, 0x3bd5a349,
-	0xb9853498, 0x84e51d28, 0xc34567f8, 0xfe254e48,
-	0x4c059258, 0x7165bbe8, 0x36c5c138, 0x0ba5e888,
-	0x28d4c7df, 0x15b4ee6f, 0x521494bf, 0x6f74bd0f,
-	0xdd54611f, 0xe03448af, 0xa794327f, 0x9af41bcf,
-	0x18a48c1e, 0x25c4a5ae, 0x6264df7e, 0x5f04f6ce,
-	0xed242ade, 0xd044036e, 0x97e479be, 0xaa84500e,
-	0x4834505d, 0x755479ed, 0x32f4033d, 0x0f942a8d,
-	0xbdb4f69d, 0x80d4df2d, 0xc774a5fd, 0xfa148c4d,
-	0x78441b9c, 0x4524322c, 0x028448fc, 0x3fe4614c,
-	0x8dc4bd5c, 0xb0a494ec, 0xf704ee3c, 0xca64c78c,
-	0x00000000, 0xcb5cd3a5, 0x4dc8a10b, 0x869472ae,
-	0x9b914216, 0x50cd91b3, 0xd659e31d, 0x1d0530b8,
-	0xec53826d, 0x270f51c8, 0xa19b2366, 0x6ac7f0c3,
-	0x77c2c07b, 0xbc9e13de, 0x3a0a6170, 0xf156b2d5,
-	0x03d6029b, 0xc88ad13e, 0x4e1ea390, 0x85427035,
-	0x9847408d, 0x531b9328, 0xd58fe186, 0x1ed33223,
-	0xef8580f6, 0x24d95353, 0xa24d21fd, 0x6911f258,
-	0x7414c2e0, 0xbf481145, 0x39dc63eb, 0xf280b04e,
-	0x07ac0536, 0xccf0d693, 0x4a64a43d, 0x81387798,
-	0x9c3d4720, 0x57619485, 0xd1f5e62b, 0x1aa9358e,
-	0xebff875b, 0x20a354fe, 0xa6372650, 0x6d6bf5f5,
-	0x706ec54d, 0xbb3216e8, 0x3da66446, 0xf6fab7e3,
-	0x047a07ad, 0xcf26d408, 0x49b2a6a6, 0x82ee7503,
-	0x9feb45bb, 0x54b7961e, 0xd223e4b0, 0x197f3715,
-	0xe82985c0, 0x23755665, 0xa5e124cb, 0x6ebdf76e,
-	0x73b8c7d6, 0xb8e41473, 0x3e7066dd, 0xf52cb578,
-	0x0f580a6c, 0xc404d9c9, 0x4290ab67, 0x89cc78c2,
-	0x94c9487a, 0x5f959bdf, 0xd901e971, 0x125d3ad4,
-	0xe30b8801, 0x28575ba4, 0xaec3290a, 0x659ffaaf,
-	0x789aca17, 0xb3c619b2, 0x35526b1c, 0xfe0eb8b9,
-	0x0c8e08f7, 0xc7d2db52, 0x4146a9fc, 0x8a1a7a59,
-	0x971f4ae1, 0x5c439944, 0xdad7ebea, 0x118b384f,
-	0xe0dd8a9a, 0x2b81593f, 0xad152b91, 0x6649f834,
-	0x7b4cc88c, 0xb0101b29, 0x36846987, 0xfdd8ba22,
-	0x08f40f5a, 0xc3a8dcff, 0x453cae51, 0x8e607df4,
-	0x93654d4c, 0x58399ee9, 0xdeadec47, 0x15f13fe2,
-	0xe4a78d37, 0x2ffb5e92, 0xa96f2c3c, 0x6233ff99,
-	0x7f36cf21, 0xb46a1c84, 0x32fe6e2a, 0xf9a2bd8f,
-	0x0b220dc1, 0xc07ede64, 0x46eaacca, 0x8db67f6f,
-	0x90b34fd7, 0x5bef9c72, 0xdd7beedc, 0x16273d79,
-	0xe7718fac, 0x2c2d5c09, 0xaab92ea7, 0x61e5fd02,
-	0x7ce0cdba, 0xb7bc1e1f, 0x31286cb1, 0xfa74bf14,
-	0x1eb014d8, 0xd5ecc77d, 0x5378b5d3, 0x98246676,
-	0x852156ce, 0x4e7d856b, 0xc8e9f7c5, 0x03b52460,
-	0xf2e396b5, 0x39bf4510, 0xbf2b37be, 0x7477e41b,
-	0x6972d4a3, 0xa22e0706, 0x24ba75a8, 0xefe6a60d,
-	0x1d661643, 0xd63ac5e6, 0x50aeb748, 0x9bf264ed,
-	0x86f75455, 0x4dab87f0, 0xcb3ff55e, 0x006326fb,
-	0xf135942e, 0x3a69478b, 0xbcfd3525, 0x77a1e680,
-	0x6aa4d638, 0xa1f8059d, 0x276c7733, 0xec30a496,
-	0x191c11ee, 0xd240c24b, 0x54d4b0e5, 0x9f886340,
-	0x828d53f8, 0x49d1805d, 0xcf45f2f3, 0x04192156,
-	0xf54f9383, 0x3e134026, 0xb8873288, 0x73dbe12d,
-	0x6eded195, 0xa5820230, 0x2316709e, 0xe84aa33b,
-	0x1aca1375, 0xd196c0d0, 0x5702b27e, 0x9c5e61db,
-	0x815b5163, 0x4a0782c6, 0xcc93f068, 0x07cf23cd,
-	0xf6999118, 0x3dc542bd, 0xbb513013, 0x700de3b6,
-	0x6d08d30e, 0xa65400ab, 0x20c07205, 0xeb9ca1a0,
-	0x11e81eb4, 0xdab4cd11, 0x5c20bfbf, 0x977c6c1a,
-	0x8a795ca2, 0x41258f07, 0xc7b1fda9, 0x0ced2e0c,
-	0xfdbb9cd9, 0x36e74f7c, 0xb0733dd2, 0x7b2fee77,
-	0x662adecf, 0xad760d6a, 0x2be27fc4, 0xe0beac61,
-	0x123e1c2f, 0xd962cf8a, 0x5ff6bd24, 0x94aa6e81,
-	0x89af5e39, 0x42f38d9c, 0xc467ff32, 0x0f3b2c97,
-	0xfe6d9e42, 0x35314de7, 0xb3a53f49, 0x78f9ecec,
-	0x65fcdc54, 0xaea00ff1, 0x28347d5f, 0xe368aefa,
-	0x16441b82, 0xdd18c827, 0x5b8cba89, 0x90d0692c,
-	0x8dd55994, 0x46898a31, 0xc01df89f, 0x0b412b3a,
-	0xfa1799ef, 0x314b4a4a, 0xb7df38e4, 0x7c83eb41,
-	0x6186dbf9, 0xaada085c, 0x2c4e7af2, 0xe712a957,
-	0x15921919, 0xdececabc, 0x585ab812, 0x93066bb7,
-	0x8e035b0f, 0x455f88aa, 0xc3cbfa04, 0x089729a1,
-	0xf9c19b74, 0x329d48d1, 0xb4093a7f, 0x7f55e9da,
-	0x6250d962, 0xa90c0ac7, 0x2f987869, 0xe4c4abcc,
-	0x00000000, 0xa6770bb4, 0x979f1129, 0x31e81a9d,
-	0xf44f2413, 0x52382fa7, 0x63d0353a, 0xc5a73e8e,
-	0x33ef4e67, 0x959845d3, 0xa4705f4e, 0x020754fa,
-	0xc7a06a74, 0x61d761c0, 0x503f7b5d, 0xf64870e9,
-	0x67de9cce, 0xc1a9977a, 0xf0418de7, 0x56368653,
-	0x9391b8dd, 0x35e6b369, 0x040ea9f4, 0xa279a240,
-	0x5431d2a9, 0xf246d91d, 0xc3aec380, 0x65d9c834,
-	0xa07ef6ba, 0x0609fd0e, 0x37e1e793, 0x9196ec27,
-	0xcfbd399c, 0x69ca3228, 0x582228b5, 0xfe552301,
-	0x3bf21d8f, 0x9d85163b, 0xac6d0ca6, 0x0a1a0712,
-	0xfc5277fb, 0x5a257c4f, 0x6bcd66d2, 0xcdba6d66,
-	0x081d53e8, 0xae6a585c, 0x9f8242c1, 0x39f54975,
-	0xa863a552, 0x0e14aee6, 0x3ffcb47b, 0x998bbfcf,
-	0x5c2c8141, 0xfa5b8af5, 0xcbb39068, 0x6dc49bdc,
-	0x9b8ceb35, 0x3dfbe081, 0x0c13fa1c, 0xaa64f1a8,
-	0x6fc3cf26, 0xc9b4c492, 0xf85cde0f, 0x5e2bd5bb,
-	0x440b7579, 0xe27c7ecd, 0xd3946450, 0x75e36fe4,
-	0xb044516a, 0x16335ade, 0x27db4043, 0x81ac4bf7,
-	0x77e43b1e, 0xd19330aa, 0xe07b2a37, 0x460c2183,
-	0x83ab1f0d, 0x25dc14b9, 0x14340e24, 0xb2430590,
-	0x23d5e9b7, 0x85a2e203, 0xb44af89e, 0x123df32a,
-	0xd79acda4, 0x71edc610, 0x4005dc8d, 0xe672d739,
-	0x103aa7d0, 0xb64dac64, 0x87a5b6f9, 0x21d2bd4d,
-	0xe47583c3, 0x42028877, 0x73ea92ea, 0xd59d995e,
-	0x8bb64ce5, 0x2dc14751, 0x1c295dcc, 0xba5e5678,
-	0x7ff968f6, 0xd98e6342, 0xe86679df, 0x4e11726b,
-	0xb8590282, 0x1e2e0936, 0x2fc613ab, 0x89b1181f,
-	0x4c162691, 0xea612d25, 0xdb8937b8, 0x7dfe3c0c,
-	0xec68d02b, 0x4a1fdb9f, 0x7bf7c102, 0xdd80cab6,
-	0x1827f438, 0xbe50ff8c, 0x8fb8e511, 0x29cfeea5,
-	0xdf879e4c, 0x79f095f8, 0x48188f65, 0xee6f84d1,
-	0x2bc8ba5f, 0x8dbfb1eb, 0xbc57ab76, 0x1a20a0c2,
-	0x8816eaf2, 0x2e61e146, 0x1f89fbdb, 0xb9fef06f,
-	0x7c59cee1, 0xda2ec555, 0xebc6dfc8, 0x4db1d47c,
-	0xbbf9a495, 0x1d8eaf21, 0x2c66b5bc, 0x8a11be08,
-	0x4fb68086, 0xe9c18b32, 0xd82991af, 0x7e5e9a1b,
-	0xefc8763c, 0x49bf7d88, 0x78576715, 0xde206ca1,
-	0x1b87522f, 0xbdf0599b, 0x8c184306, 0x2a6f48b2,
-	0xdc27385b, 0x7a5033ef, 0x4bb82972, 0xedcf22c6,
-	0x28681c48, 0x8e1f17fc, 0xbff70d61, 0x198006d5,
-	0x47abd36e, 0xe1dcd8da, 0xd034c247, 0x7643c9f3,
-	0xb3e4f77d, 0x1593fcc9, 0x247be654, 0x820cede0,
-	0x74449d09, 0xd23396bd, 0xe3db8c20, 0x45ac8794,
-	0x800bb91a, 0x267cb2ae, 0x1794a833, 0xb1e3a387,
-	0x20754fa0, 0x86024414, 0xb7ea5e89, 0x119d553d,
-	0xd43a6bb3, 0x724d6007, 0x43a57a9a, 0xe5d2712e,
-	0x139a01c7, 0xb5ed0a73, 0x840510ee, 0x22721b5a,
-	0xe7d525d4, 0x41a22e60, 0x704a34fd, 0xd63d3f49,
-	0xcc1d9f8b, 0x6a6a943f, 0x5b828ea2, 0xfdf58516,
-	0x3852bb98, 0x9e25b02c, 0xafcdaab1, 0x09baa105,
-	0xfff2d1ec, 0x5985da58, 0x686dc0c5, 0xce1acb71,
-	0x0bbdf5ff, 0xadcafe4b, 0x9c22e4d6, 0x3a55ef62,
-	0xabc30345, 0x0db408f1, 0x3c5c126c, 0x9a2b19d8,
-	0x5f8c2756, 0xf9fb2ce2, 0xc813367f, 0x6e643dcb,
-	0x982c4d22, 0x3e5b4696, 0x0fb35c0b, 0xa9c457bf,
-	0x6c636931, 0xca146285, 0xfbfc7818, 0x5d8b73ac,
-	0x03a0a617, 0xa5d7ada3, 0x943fb73e, 0x3248bc8a,
-	0xf7ef8204, 0x519889b0, 0x6070932d, 0xc6079899,
-	0x304fe870, 0x9638e3c4, 0xa7d0f959, 0x01a7f2ed,
-	0xc400cc63, 0x6277c7d7, 0x539fdd4a, 0xf5e8d6fe,
-	0x647e3ad9, 0xc209316d, 0xf3e12bf0, 0x55962044,
-	0x90311eca, 0x3646157e, 0x07ae0fe3, 0xa1d90457,
-	0x579174be, 0xf1e67f0a, 0xc00e6597, 0x66796e23,
-	0xa3de50ad, 0x05a95b19, 0x34414184, 0x92364a30,
-	0x00000000, 0xccaa009e, 0x4225077d, 0x8e8f07e3,
-	0x844a0efa, 0x48e00e64, 0xc66f0987, 0x0ac50919,
-	0xd3e51bb5, 0x1f4f1b2b, 0x91c01cc8, 0x5d6a1c56,
-	0x57af154f, 0x9b0515d1, 0x158a1232, 0xd92012ac,
-	0x7cbb312b, 0xb01131b5, 0x3e9e3656, 0xf23436c8,
-	0xf8f13fd1, 0x345b3f4f, 0xbad438ac, 0x767e3832,
-	0xaf5e2a9e, 0x63f42a00, 0xed7b2de3, 0x21d12d7d,
-	0x2b142464, 0xe7be24fa, 0x69312319, 0xa59b2387,
-	0xf9766256, 0x35dc62c8, 0xbb53652b, 0x77f965b5,
-	0x7d3c6cac, 0xb1966c32, 0x3f196bd1, 0xf3b36b4f,
-	0x2a9379e3, 0xe639797d, 0x68b67e9e, 0xa41c7e00,
-	0xaed97719, 0x62737787, 0xecfc7064, 0x205670fa,
-	0x85cd537d, 0x496753e3, 0xc7e85400, 0x0b42549e,
-	0x01875d87, 0xcd2d5d19, 0x43a25afa, 0x8f085a64,
-	0x562848c8, 0x9a824856, 0x140d4fb5, 0xd8a74f2b,
-	0xd2624632, 0x1ec846ac, 0x9047414f, 0x5ced41d1,
-	0x299dc2ed, 0xe537c273, 0x6bb8c590, 0xa712c50e,
-	0xadd7cc17, 0x617dcc89, 0xeff2cb6a, 0x2358cbf4,
-	0xfa78d958, 0x36d2d9c6, 0xb85dde25, 0x74f7debb,
-	0x7e32d7a2, 0xb298d73c, 0x3c17d0df, 0xf0bdd041,
-	0x5526f3c6, 0x998cf358, 0x1703f4bb, 0xdba9f425,
-	0xd16cfd3c, 0x1dc6fda2, 0x9349fa41, 0x5fe3fadf,
-	0x86c3e873, 0x4a69e8ed, 0xc4e6ef0e, 0x084cef90,
-	0x0289e689, 0xce23e617, 0x40ace1f4, 0x8c06e16a,
-	0xd0eba0bb, 0x1c41a025, 0x92cea7c6, 0x5e64a758,
-	0x54a1ae41, 0x980baedf, 0x1684a93c, 0xda2ea9a2,
-	0x030ebb0e, 0xcfa4bb90, 0x412bbc73, 0x8d81bced,
-	0x8744b5f4, 0x4beeb56a, 0xc561b289, 0x09cbb217,
-	0xac509190, 0x60fa910e, 0xee7596ed, 0x22df9673,
-	0x281a9f6a, 0xe4b09ff4, 0x6a3f9817, 0xa6959889,
-	0x7fb58a25, 0xb31f8abb, 0x3d908d58, 0xf13a8dc6,
-	0xfbff84df, 0x37558441, 0xb9da83a2, 0x7570833c,
-	0x533b85da, 0x9f918544, 0x111e82a7, 0xddb48239,
-	0xd7718b20, 0x1bdb8bbe, 0x95548c5d, 0x59fe8cc3,
-	0x80de9e6f, 0x4c749ef1, 0xc2fb9912, 0x0e51998c,
-	0x04949095, 0xc83e900b, 0x46b197e8, 0x8a1b9776,
-	0x2f80b4f1, 0xe32ab46f, 0x6da5b38c, 0xa10fb312,
-	0xabcaba0b, 0x6760ba95, 0xe9efbd76, 0x2545bde8,
-	0xfc65af44, 0x30cfafda, 0xbe40a839, 0x72eaa8a7,
-	0x782fa1be, 0xb485a120, 0x3a0aa6c3, 0xf6a0a65d,
-	0xaa4de78c, 0x66e7e712, 0xe868e0f1, 0x24c2e06f,
-	0x2e07e976, 0xe2ade9e8, 0x6c22ee0b, 0xa088ee95,
-	0x79a8fc39, 0xb502fca7, 0x3b8dfb44, 0xf727fbda,
-	0xfde2f2c3, 0x3148f25d, 0xbfc7f5be, 0x736df520,
-	0xd6f6d6a7, 0x1a5cd639, 0x94d3d1da, 0x5879d144,
-	0x52bcd85d, 0x9e16d8c3, 0x1099df20, 0xdc33dfbe,
-	0x0513cd12, 0xc9b9cd8c, 0x4736ca6f, 0x8b9ccaf1,
-	0x8159c3e8, 0x4df3c376, 0xc37cc495, 0x0fd6c40b,
-	0x7aa64737, 0xb60c47a9, 0x3883404a, 0xf42940d4,
-	0xfeec49cd, 0x32464953, 0xbcc94eb0, 0x70634e2e,
-	0xa9435c82, 0x65e95c1c, 0xeb665bff, 0x27cc5b61,
-	0x2d095278, 0xe1a352e6, 0x6f2c5505, 0xa386559b,
-	0x061d761c, 0xcab77682, 0x44387161, 0x889271ff,
-	0x825778e6, 0x4efd7878, 0xc0727f9b, 0x0cd87f05,
-	0xd5f86da9, 0x19526d37, 0x97dd6ad4, 0x5b776a4a,
-	0x51b26353, 0x9d1863cd, 0x1397642e, 0xdf3d64b0,
-	0x83d02561, 0x4f7a25ff, 0xc1f5221c, 0x0d5f2282,
-	0x079a2b9b, 0xcb302b05, 0x45bf2ce6, 0x89152c78,
-	0x50353ed4, 0x9c9f3e4a, 0x121039a9, 0xdeba3937,
-	0xd47f302e, 0x18d530b0, 0x965a3753, 0x5af037cd,
-	0xff6b144a, 0x33c114d4, 0xbd4e1337, 0x71e413a9,
-	0x7b211ab0, 0xb78b1a2e, 0x39041dcd, 0xf5ae1d53,
-	0x2c8e0fff, 0xe0240f61, 0x6eab0882, 0xa201081c,
-	0xa8c40105, 0x646e019b, 0xeae10678, 0x264b06e6,
-};
diff --git a/vendor/core/vendor/libdeflate/lib/decompress_template.h b/vendor/core/vendor/libdeflate/lib/decompress_template.h
deleted file mode 100644
index 8c874c36..00000000
--- a/vendor/core/vendor/libdeflate/lib/decompress_template.h
+++ /dev/null
@@ -1,777 +0,0 @@
-/*
- * decompress_template.h
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-/*
- * This is the actual DEFLATE decompression routine, lifted out of
- * deflate_decompress.c so that it can be compiled multiple times with different
- * target instruction sets.
- */
-
-#ifndef ATTRIBUTES
-#  define ATTRIBUTES
-#endif
-#ifndef EXTRACT_VARBITS
-#  define EXTRACT_VARBITS(word, count)	((word) & BITMASK(count))
-#endif
-#ifndef EXTRACT_VARBITS8
-#  define EXTRACT_VARBITS8(word, count)	((word) & BITMASK((u8)(count)))
-#endif
-
-static ATTRIBUTES MAYBE_UNUSED enum libdeflate_result
-FUNCNAME(struct libdeflate_decompressor * restrict d,
-	 const void * restrict in, size_t in_nbytes,
-	 void * restrict out, size_t out_nbytes_avail,
-	 size_t *actual_in_nbytes_ret, size_t *actual_out_nbytes_ret)
-{
-	u8 *out_next = out;
-	u8 * const out_end = out_next + out_nbytes_avail;
-	u8 * const out_fastloop_end =
-		out_end - MIN(out_nbytes_avail, FASTLOOP_MAX_BYTES_WRITTEN);
-
-	/* Input bitstream state; see deflate_decompress.c for documentation */
-	const u8 *in_next = in;
-	const u8 * const in_end = in_next + in_nbytes;
-	const u8 * const in_fastloop_end =
-		in_end - MIN(in_nbytes, FASTLOOP_MAX_BYTES_READ);
-	bitbuf_t bitbuf = 0;
-	bitbuf_t saved_bitbuf;
-	u32 bitsleft = 0;
-	size_t overread_count = 0;
-
-	bool is_final_block;
-	unsigned block_type;
-	unsigned num_litlen_syms;
-	unsigned num_offset_syms;
-	bitbuf_t litlen_tablemask;
-	u32 entry;
-
-next_block:
-	/* Starting to read the next block */
-	;
-
-	STATIC_ASSERT(CAN_CONSUME(1 + 2 + 5 + 5 + 4 + 3));
-	REFILL_BITS();
-
-	/* BFINAL: 1 bit */
-	is_final_block = bitbuf & BITMASK(1);
-
-	/* BTYPE: 2 bits */
-	block_type = (bitbuf >> 1) & BITMASK(2);
-
-	if (block_type == DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN) {
-
-		/* Dynamic Huffman block */
-
-		/* The order in which precode lengths are stored */
-		static const u8 deflate_precode_lens_permutation[DEFLATE_NUM_PRECODE_SYMS] = {
-			16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
-		};
-
-		unsigned num_explicit_precode_lens;
-		unsigned i;
-
-		/* Read the codeword length counts. */
-
-		STATIC_ASSERT(DEFLATE_NUM_LITLEN_SYMS == 257 + BITMASK(5));
-		num_litlen_syms = 257 + ((bitbuf >> 3) & BITMASK(5));
-
-		STATIC_ASSERT(DEFLATE_NUM_OFFSET_SYMS == 1 + BITMASK(5));
-		num_offset_syms = 1 + ((bitbuf >> 8) & BITMASK(5));
-
-		STATIC_ASSERT(DEFLATE_NUM_PRECODE_SYMS == 4 + BITMASK(4));
-		num_explicit_precode_lens = 4 + ((bitbuf >> 13) & BITMASK(4));
-
-		d->static_codes_loaded = false;
-
-		/*
-		 * Read the precode codeword lengths.
-		 *
-		 * A 64-bit bitbuffer is just one bit too small to hold the
-		 * maximum number of precode lens, so to minimize branches we
-		 * merge one len with the previous fields.
-		 */
-		STATIC_ASSERT(DEFLATE_MAX_PRE_CODEWORD_LEN == (1 << 3) - 1);
-		if (CAN_CONSUME(3 * (DEFLATE_NUM_PRECODE_SYMS - 1))) {
-			d->u.precode_lens[deflate_precode_lens_permutation[0]] =
-				(bitbuf >> 17) & BITMASK(3);
-			bitbuf >>= 20;
-			bitsleft -= 20;
-			REFILL_BITS();
-			i = 1;
-			do {
-				d->u.precode_lens[deflate_precode_lens_permutation[i]] =
-					bitbuf & BITMASK(3);
-				bitbuf >>= 3;
-				bitsleft -= 3;
-			} while (++i < num_explicit_precode_lens);
-		} else {
-			bitbuf >>= 17;
-			bitsleft -= 17;
-			i = 0;
-			do {
-				if ((u8)bitsleft < 3)
-					REFILL_BITS();
-				d->u.precode_lens[deflate_precode_lens_permutation[i]] =
-					bitbuf & BITMASK(3);
-				bitbuf >>= 3;
-				bitsleft -= 3;
-			} while (++i < num_explicit_precode_lens);
-		}
-		for (; i < DEFLATE_NUM_PRECODE_SYMS; i++)
-			d->u.precode_lens[deflate_precode_lens_permutation[i]] = 0;
-
-		/* Build the decode table for the precode. */
-		SAFETY_CHECK(build_precode_decode_table(d));
-
-		/* Decode the litlen and offset codeword lengths. */
-		i = 0;
-		do {
-			unsigned presym;
-			u8 rep_val;
-			unsigned rep_count;
-
-			if ((u8)bitsleft < DEFLATE_MAX_PRE_CODEWORD_LEN + 7)
-				REFILL_BITS();
-
-			/*
-			 * The code below assumes that the precode decode table
-			 * doesn't have any subtables.
-			 */
-			STATIC_ASSERT(PRECODE_TABLEBITS == DEFLATE_MAX_PRE_CODEWORD_LEN);
-
-			/* Decode the next precode symbol. */
-			entry = d->u.l.precode_decode_table[
-				bitbuf & BITMASK(DEFLATE_MAX_PRE_CODEWORD_LEN)];
-			bitbuf >>= (u8)entry;
-			bitsleft -= entry; /* optimization: subtract full entry */
-			presym = entry >> 16;
-
-			if (presym < 16) {
-				/* Explicit codeword length */
-				d->u.l.lens[i++] = presym;
-				continue;
-			}
-
-			/* Run-length encoded codeword lengths */
-
-			/*
-			 * Note: we don't need to immediately verify that the
-			 * repeat count doesn't overflow the number of elements,
-			 * since we've sized the lens array to have enough extra
-			 * space to allow for the worst-case overrun (138 zeroes
-			 * when only 1 length was remaining).
-			 *
-			 * In the case of the small repeat counts (presyms 16
-			 * and 17), it is fastest to always write the maximum
-			 * number of entries.  That gets rid of branches that
-			 * would otherwise be required.
-			 *
-			 * It is not just because of the numerical order that
-			 * our checks go in the order 'presym < 16', 'presym ==
-			 * 16', and 'presym == 17'.  For typical data this is
-			 * ordered from most frequent to least frequent case.
-			 */
-			STATIC_ASSERT(DEFLATE_MAX_LENS_OVERRUN == 138 - 1);
-
-			if (presym == 16) {
-				/* Repeat the previous length 3 - 6 times. */
-				SAFETY_CHECK(i != 0);
-				rep_val = d->u.l.lens[i - 1];
-				STATIC_ASSERT(3 + BITMASK(2) == 6);
-				rep_count = 3 + (bitbuf & BITMASK(2));
-				bitbuf >>= 2;
-				bitsleft -= 2;
-				d->u.l.lens[i + 0] = rep_val;
-				d->u.l.lens[i + 1] = rep_val;
-				d->u.l.lens[i + 2] = rep_val;
-				d->u.l.lens[i + 3] = rep_val;
-				d->u.l.lens[i + 4] = rep_val;
-				d->u.l.lens[i + 5] = rep_val;
-				i += rep_count;
-			} else if (presym == 17) {
-				/* Repeat zero 3 - 10 times. */
-				STATIC_ASSERT(3 + BITMASK(3) == 10);
-				rep_count = 3 + (bitbuf & BITMASK(3));
-				bitbuf >>= 3;
-				bitsleft -= 3;
-				d->u.l.lens[i + 0] = 0;
-				d->u.l.lens[i + 1] = 0;
-				d->u.l.lens[i + 2] = 0;
-				d->u.l.lens[i + 3] = 0;
-				d->u.l.lens[i + 4] = 0;
-				d->u.l.lens[i + 5] = 0;
-				d->u.l.lens[i + 6] = 0;
-				d->u.l.lens[i + 7] = 0;
-				d->u.l.lens[i + 8] = 0;
-				d->u.l.lens[i + 9] = 0;
-				i += rep_count;
-			} else {
-				/* Repeat zero 11 - 138 times. */
-				STATIC_ASSERT(11 + BITMASK(7) == 138);
-				rep_count = 11 + (bitbuf & BITMASK(7));
-				bitbuf >>= 7;
-				bitsleft -= 7;
-				memset(&d->u.l.lens[i], 0,
-				       rep_count * sizeof(d->u.l.lens[i]));
-				i += rep_count;
-			}
-		} while (i < num_litlen_syms + num_offset_syms);
-
-		/* Unnecessary, but check this for consistency with zlib. */
-		SAFETY_CHECK(i == num_litlen_syms + num_offset_syms);
-
-	} else if (block_type == DEFLATE_BLOCKTYPE_UNCOMPRESSED) {
-		u16 len, nlen;
-
-		/*
-		 * Uncompressed block: copy 'len' bytes literally from the input
-		 * buffer to the output buffer.
-		 */
-
-		bitsleft -= 3; /* for BTYPE and BFINAL */
-
-		/*
-		 * Align the bitstream to the next byte boundary.  This means
-		 * the next byte boundary as if we were reading a byte at a
-		 * time.  Therefore, we have to rewind 'in_next' by any bytes
-		 * that have been refilled but not actually consumed yet (not
-		 * counting overread bytes, which don't increment 'in_next').
-		 */
-		bitsleft = (u8)bitsleft;
-		SAFETY_CHECK(overread_count <= (bitsleft >> 3));
-		in_next -= (bitsleft >> 3) - overread_count;
-		overread_count = 0;
-		bitbuf = 0;
-		bitsleft = 0;
-
-		SAFETY_CHECK(in_end - in_next >= 4);
-		len = get_unaligned_le16(in_next);
-		nlen = get_unaligned_le16(in_next + 2);
-		in_next += 4;
-
-		SAFETY_CHECK(len == (u16)~nlen);
-		if (unlikely(len > out_end - out_next))
-			return LIBDEFLATE_INSUFFICIENT_SPACE;
-		SAFETY_CHECK(len <= in_end - in_next);
-
-		memcpy(out_next, in_next, len);
-		in_next += len;
-		out_next += len;
-
-		goto block_done;
-
-	} else {
-		unsigned i;
-
-		SAFETY_CHECK(block_type == DEFLATE_BLOCKTYPE_STATIC_HUFFMAN);
-
-		/*
-		 * Static Huffman block: build the decode tables for the static
-		 * codes.  Skip doing so if the tables are already set up from
-		 * an earlier static block; this speeds up decompression of
-		 * degenerate input of many empty or very short static blocks.
-		 *
-		 * Afterwards, the remainder is the same as decompressing a
-		 * dynamic Huffman block.
-		 */
-
-		bitbuf >>= 3; /* for BTYPE and BFINAL */
-		bitsleft -= 3;
-
-		if (d->static_codes_loaded)
-			goto have_decode_tables;
-
-		d->static_codes_loaded = true;
-
-		STATIC_ASSERT(DEFLATE_NUM_LITLEN_SYMS == 288);
-		STATIC_ASSERT(DEFLATE_NUM_OFFSET_SYMS == 32);
-
-		for (i = 0; i < 144; i++)
-			d->u.l.lens[i] = 8;
-		for (; i < 256; i++)
-			d->u.l.lens[i] = 9;
-		for (; i < 280; i++)
-			d->u.l.lens[i] = 7;
-		for (; i < 288; i++)
-			d->u.l.lens[i] = 8;
-
-		for (; i < 288 + 32; i++)
-			d->u.l.lens[i] = 5;
-
-		num_litlen_syms = 288;
-		num_offset_syms = 32;
-	}
-
-	/* Decompressing a Huffman block (either dynamic or static) */
-
-	SAFETY_CHECK(build_offset_decode_table(d, num_litlen_syms, num_offset_syms));
-	SAFETY_CHECK(build_litlen_decode_table(d, num_litlen_syms, num_offset_syms));
-have_decode_tables:
-	litlen_tablemask = BITMASK(d->litlen_tablebits);
-
-	/*
-	 * This is the "fastloop" for decoding literals and matches.  It does
-	 * bounds checks on in_next and out_next in the loop conditions so that
-	 * additional bounds checks aren't needed inside the loop body.
-	 *
-	 * To reduce latency, the bitbuffer is refilled and the next litlen
-	 * decode table entry is preloaded before each loop iteration.
-	 */
-	if (in_next >= in_fastloop_end || out_next >= out_fastloop_end)
-		goto generic_loop;
-	REFILL_BITS_IN_FASTLOOP();
-	entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-	do {
-		u32 length, offset, lit;
-		const u8 *src;
-		u8 *dst;
-
-		/*
-		 * Consume the bits for the litlen decode table entry.  Save the
-		 * original bitbuf for later, in case the extra match length
-		 * bits need to be extracted from it.
-		 */
-		saved_bitbuf = bitbuf;
-		bitbuf >>= (u8)entry;
-		bitsleft -= entry; /* optimization: subtract full entry */
-
-		/*
-		 * Begin by checking for a "fast" literal, i.e. a literal that
-		 * doesn't need a subtable.
-		 */
-		if (entry & HUFFDEC_LITERAL) {
-			/*
-			 * On 64-bit platforms, we decode up to 2 extra fast
-			 * literals in addition to the primary item, as this
-			 * increases performance and still leaves enough bits
-			 * remaining for what follows.  We could actually do 3,
-			 * assuming LITLEN_TABLEBITS=11, but that actually
-			 * decreases performance slightly (perhaps by messing
-			 * with the branch prediction of the conditional refill
-			 * that happens later while decoding the match offset).
-			 *
-			 * Note: the definitions of FASTLOOP_MAX_BYTES_WRITTEN
-			 * and FASTLOOP_MAX_BYTES_READ need to be updated if the
-			 * number of extra literals decoded here is changed.
-			 */
-			if (/* enough bits for 2 fast literals + length + offset preload? */
-			    CAN_CONSUME_AND_THEN_PRELOAD(2 * LITLEN_TABLEBITS +
-							 LENGTH_MAXBITS,
-							 OFFSET_TABLEBITS) &&
-			    /* enough bits for 2 fast literals + slow literal + litlen preload? */
-			    CAN_CONSUME_AND_THEN_PRELOAD(2 * LITLEN_TABLEBITS +
-							 DEFLATE_MAX_LITLEN_CODEWORD_LEN,
-							 LITLEN_TABLEBITS)) {
-				/* 1st extra fast literal */
-				lit = entry >> 16;
-				entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-				saved_bitbuf = bitbuf;
-				bitbuf >>= (u8)entry;
-				bitsleft -= entry;
-				*out_next++ = lit;
-				if (entry & HUFFDEC_LITERAL) {
-					/* 2nd extra fast literal */
-					lit = entry >> 16;
-					entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-					saved_bitbuf = bitbuf;
-					bitbuf >>= (u8)entry;
-					bitsleft -= entry;
-					*out_next++ = lit;
-					if (entry & HUFFDEC_LITERAL) {
-						/*
-						 * Another fast literal, but
-						 * this one is in lieu of the
-						 * primary item, so it doesn't
-						 * count as one of the extras.
-						 */
-						lit = entry >> 16;
-						entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-						REFILL_BITS_IN_FASTLOOP();
-						*out_next++ = lit;
-						continue;
-					}
-				}
-			} else {
-				/*
-				 * Decode a literal.  While doing so, preload
-				 * the next litlen decode table entry and refill
-				 * the bitbuffer.  To reduce latency, we've
-				 * arranged for there to be enough "preloadable"
-				 * bits remaining to do the table preload
-				 * independently of the refill.
-				 */
-				STATIC_ASSERT(CAN_CONSUME_AND_THEN_PRELOAD(
-						LITLEN_TABLEBITS, LITLEN_TABLEBITS));
-				lit = entry >> 16;
-				entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-				REFILL_BITS_IN_FASTLOOP();
-				*out_next++ = lit;
-				continue;
-			}
-		}
-
-		/*
-		 * It's not a literal entry, so it can be a length entry, a
-		 * subtable pointer entry, or an end-of-block entry.  Detect the
-		 * two unlikely cases by testing the HUFFDEC_EXCEPTIONAL flag.
-		 */
-		if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
-			/* Subtable pointer or end-of-block entry */
-
-			if (unlikely(entry & HUFFDEC_END_OF_BLOCK))
-				goto block_done;
-
-			/*
-			 * A subtable is required.  Load and consume the
-			 * subtable entry.  The subtable entry can be of any
-			 * type: literal, length, or end-of-block.
-			 */
-			entry = d->u.litlen_decode_table[(entry >> 16) +
-				EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
-			saved_bitbuf = bitbuf;
-			bitbuf >>= (u8)entry;
-			bitsleft -= entry;
-
-			/*
-			 * 32-bit platforms that use the byte-at-a-time refill
-			 * method have to do a refill here for there to always
-			 * be enough bits to decode a literal that requires a
-			 * subtable, then preload the next litlen decode table
-			 * entry; or to decode a match length that requires a
-			 * subtable, then preload the offset decode table entry.
-			 */
-			if (!CAN_CONSUME_AND_THEN_PRELOAD(DEFLATE_MAX_LITLEN_CODEWORD_LEN,
-							  LITLEN_TABLEBITS) ||
-			    !CAN_CONSUME_AND_THEN_PRELOAD(LENGTH_MAXBITS,
-							  OFFSET_TABLEBITS))
-				REFILL_BITS_IN_FASTLOOP();
-			if (entry & HUFFDEC_LITERAL) {
-				/* Decode a literal that required a subtable. */
-				lit = entry >> 16;
-				entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-				REFILL_BITS_IN_FASTLOOP();
-				*out_next++ = lit;
-				continue;
-			}
-			if (unlikely(entry & HUFFDEC_END_OF_BLOCK))
-				goto block_done;
-			/* Else, it's a length that required a subtable. */
-		}
-
-		/*
-		 * Decode the match length: the length base value associated
-		 * with the litlen symbol (which we extract from the decode
-		 * table entry), plus the extra length bits.  We don't need to
-		 * consume the extra length bits here, as they were included in
-		 * the bits consumed by the entry earlier.  We also don't need
-		 * to check for too-long matches here, as this is inside the
-		 * fastloop where it's already been verified that the output
-		 * buffer has enough space remaining to copy a max-length match.
-		 */
-		length = entry >> 16;
-		length += EXTRACT_VARBITS8(saved_bitbuf, entry) >> (u8)(entry >> 8);
-
-		/*
-		 * Decode the match offset.  There are enough "preloadable" bits
-		 * remaining to preload the offset decode table entry, but a
-		 * refill might be needed before consuming it.
-		 */
-		STATIC_ASSERT(CAN_CONSUME_AND_THEN_PRELOAD(LENGTH_MAXFASTBITS,
-							   OFFSET_TABLEBITS));
-		entry = d->offset_decode_table[bitbuf & BITMASK(OFFSET_TABLEBITS)];
-		if (CAN_CONSUME_AND_THEN_PRELOAD(OFFSET_MAXBITS,
-						 LITLEN_TABLEBITS)) {
-			/*
-			 * Decoding a match offset on a 64-bit platform.  We may
-			 * need to refill once, but then we can decode the whole
-			 * offset and preload the next litlen table entry.
-			 */
-			if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
-				/* Offset codeword requires a subtable */
-				if (unlikely((u8)bitsleft < OFFSET_MAXBITS +
-					     LITLEN_TABLEBITS - PRELOAD_SLACK))
-					REFILL_BITS_IN_FASTLOOP();
-				bitbuf >>= OFFSET_TABLEBITS;
-				bitsleft -= OFFSET_TABLEBITS;
-				entry = d->offset_decode_table[(entry >> 16) +
-					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
-			} else if (unlikely((u8)bitsleft < OFFSET_MAXFASTBITS +
-					    LITLEN_TABLEBITS - PRELOAD_SLACK))
-				REFILL_BITS_IN_FASTLOOP();
-		} else {
-			/* Decoding a match offset on a 32-bit platform */
-			REFILL_BITS_IN_FASTLOOP();
-			if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
-				/* Offset codeword requires a subtable */
-				bitbuf >>= OFFSET_TABLEBITS;
-				bitsleft -= OFFSET_TABLEBITS;
-				entry = d->offset_decode_table[(entry >> 16) +
-					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
-				REFILL_BITS_IN_FASTLOOP();
-				/* No further refill needed before extra bits */
-				STATIC_ASSERT(CAN_CONSUME(
-					OFFSET_MAXBITS - OFFSET_TABLEBITS));
-			} else {
-				/* No refill needed before extra bits */
-				STATIC_ASSERT(CAN_CONSUME(OFFSET_MAXFASTBITS));
-			}
-		}
-		saved_bitbuf = bitbuf;
-		bitbuf >>= (u8)entry;
-		bitsleft -= entry; /* optimization: subtract full entry */
-		offset = entry >> 16;
-		offset += EXTRACT_VARBITS8(saved_bitbuf, entry) >> (u8)(entry >> 8);
-
-		/* Validate the match offset; needed even in the fastloop. */
-		SAFETY_CHECK(offset <= out_next - (const u8 *)out);
-		src = out_next - offset;
-		dst = out_next;
-		out_next += length;
-
-		/*
-		 * Before starting to issue the instructions to copy the match,
-		 * refill the bitbuffer and preload the litlen decode table
-		 * entry for the next loop iteration.  This can increase
-		 * performance by allowing the latency of the match copy to
-		 * overlap with these other operations.  To further reduce
-		 * latency, we've arranged for there to be enough bits remaining
-		 * to do the table preload independently of the refill, except
-		 * on 32-bit platforms using the byte-at-a-time refill method.
-		 */
-		if (!CAN_CONSUME_AND_THEN_PRELOAD(
-			MAX(OFFSET_MAXBITS - OFFSET_TABLEBITS,
-			    OFFSET_MAXFASTBITS),
-			LITLEN_TABLEBITS) &&
-		    unlikely((u8)bitsleft < LITLEN_TABLEBITS - PRELOAD_SLACK))
-			REFILL_BITS_IN_FASTLOOP();
-		entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-		REFILL_BITS_IN_FASTLOOP();
-
-		/*
-		 * Copy the match.  On most CPUs the fastest method is a
-		 * word-at-a-time copy, unconditionally copying about 5 words
-		 * since this is enough for most matches without being too much.
-		 *
-		 * The normal word-at-a-time copy works for offset >= WORDBYTES,
-		 * which is most cases.  The case of offset == 1 is also common
-		 * and is worth optimizing for, since it is just RLE encoding of
-		 * the previous byte, which is the result of compressing long
-		 * runs of the same byte.
-		 *
-		 * Writing past the match 'length' is allowed here, since it's
-		 * been ensured there is enough output space left for a slight
-		 * overrun.  FASTLOOP_MAX_BYTES_WRITTEN needs to be updated if
-		 * the maximum possible overrun here is changed.
-		 */
-		if (UNALIGNED_ACCESS_IS_FAST && offset >= WORDBYTES) {
-			store_word_unaligned(load_word_unaligned(src), dst);
-			src += WORDBYTES;
-			dst += WORDBYTES;
-			store_word_unaligned(load_word_unaligned(src), dst);
-			src += WORDBYTES;
-			dst += WORDBYTES;
-			store_word_unaligned(load_word_unaligned(src), dst);
-			src += WORDBYTES;
-			dst += WORDBYTES;
-			store_word_unaligned(load_word_unaligned(src), dst);
-			src += WORDBYTES;
-			dst += WORDBYTES;
-			store_word_unaligned(load_word_unaligned(src), dst);
-			src += WORDBYTES;
-			dst += WORDBYTES;
-			while (dst < out_next) {
-				store_word_unaligned(load_word_unaligned(src), dst);
-				src += WORDBYTES;
-				dst += WORDBYTES;
-				store_word_unaligned(load_word_unaligned(src), dst);
-				src += WORDBYTES;
-				dst += WORDBYTES;
-				store_word_unaligned(load_word_unaligned(src), dst);
-				src += WORDBYTES;
-				dst += WORDBYTES;
-				store_word_unaligned(load_word_unaligned(src), dst);
-				src += WORDBYTES;
-				dst += WORDBYTES;
-				store_word_unaligned(load_word_unaligned(src), dst);
-				src += WORDBYTES;
-				dst += WORDBYTES;
-			}
-		} else if (UNALIGNED_ACCESS_IS_FAST && offset == 1) {
-			machine_word_t v;
-
-			/*
-			 * This part tends to get auto-vectorized, so keep it
-			 * copying a multiple of 16 bytes at a time.
-			 */
-			v = (machine_word_t)0x0101010101010101 * src[0];
-			store_word_unaligned(v, dst);
-			dst += WORDBYTES;
-			store_word_unaligned(v, dst);
-			dst += WORDBYTES;
-			store_word_unaligned(v, dst);
-			dst += WORDBYTES;
-			store_word_unaligned(v, dst);
-			dst += WORDBYTES;
-			while (dst < out_next) {
-				store_word_unaligned(v, dst);
-				dst += WORDBYTES;
-				store_word_unaligned(v, dst);
-				dst += WORDBYTES;
-				store_word_unaligned(v, dst);
-				dst += WORDBYTES;
-				store_word_unaligned(v, dst);
-				dst += WORDBYTES;
-			}
-		} else if (UNALIGNED_ACCESS_IS_FAST) {
-			store_word_unaligned(load_word_unaligned(src), dst);
-			src += offset;
-			dst += offset;
-			store_word_unaligned(load_word_unaligned(src), dst);
-			src += offset;
-			dst += offset;
-			do {
-				store_word_unaligned(load_word_unaligned(src), dst);
-				src += offset;
-				dst += offset;
-				store_word_unaligned(load_word_unaligned(src), dst);
-				src += offset;
-				dst += offset;
-			} while (dst < out_next);
-		} else {
-			*dst++ = *src++;
-			*dst++ = *src++;
-			do {
-				*dst++ = *src++;
-			} while (dst < out_next);
-		}
-	} while (in_next < in_fastloop_end && out_next < out_fastloop_end);
-
-	/*
-	 * This is the generic loop for decoding literals and matches.  This
-	 * handles cases where in_next and out_next are close to the end of
-	 * their respective buffers.  Usually this loop isn't performance-
-	 * critical, as most time is spent in the fastloop above instead.  We
-	 * therefore omit some optimizations here in favor of smaller code.
-	 */
-generic_loop:
-	for (;;) {
-		u32 length, offset;
-		const u8 *src;
-		u8 *dst;
-
-		REFILL_BITS();
-		entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
-		saved_bitbuf = bitbuf;
-		bitbuf >>= (u8)entry;
-		bitsleft -= entry;
-		if (unlikely(entry & HUFFDEC_SUBTABLE_POINTER)) {
-			entry = d->u.litlen_decode_table[(entry >> 16) +
-					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
-			saved_bitbuf = bitbuf;
-			bitbuf >>= (u8)entry;
-			bitsleft -= entry;
-		}
-		length = entry >> 16;
-		if (entry & HUFFDEC_LITERAL) {
-			if (unlikely(out_next == out_end))
-				return LIBDEFLATE_INSUFFICIENT_SPACE;
-			*out_next++ = length;
-			continue;
-		}
-		if (unlikely(entry & HUFFDEC_END_OF_BLOCK))
-			goto block_done;
-		length += EXTRACT_VARBITS8(saved_bitbuf, entry) >> (u8)(entry >> 8);
-		if (unlikely(length > out_end - out_next))
-			return LIBDEFLATE_INSUFFICIENT_SPACE;
-
-		if (!CAN_CONSUME(LENGTH_MAXBITS + OFFSET_MAXBITS))
-			REFILL_BITS();
-		entry = d->offset_decode_table[bitbuf & BITMASK(OFFSET_TABLEBITS)];
-		if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
-			bitbuf >>= OFFSET_TABLEBITS;
-			bitsleft -= OFFSET_TABLEBITS;
-			entry = d->offset_decode_table[(entry >> 16) +
-					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
-			if (!CAN_CONSUME(OFFSET_MAXBITS))
-				REFILL_BITS();
-		}
-		offset = entry >> 16;
-		offset += EXTRACT_VARBITS8(bitbuf, entry) >> (u8)(entry >> 8);
-		bitbuf >>= (u8)entry;
-		bitsleft -= entry;
-
-		SAFETY_CHECK(offset <= out_next - (const u8 *)out);
-		src = out_next - offset;
-		dst = out_next;
-		out_next += length;
-
-		STATIC_ASSERT(DEFLATE_MIN_MATCH_LEN == 3);
-		*dst++ = *src++;
-		*dst++ = *src++;
-		do {
-			*dst++ = *src++;
-		} while (dst < out_next);
-	}
-
-block_done:
-	/* Finished decoding a block */
-
-	if (!is_final_block)
-		goto next_block;
-
-	/* That was the last block. */
-
-	bitsleft = (u8)bitsleft;
-
-	/*
-	 * If any of the implicit appended zero bytes were consumed (not just
-	 * refilled) before hitting end of stream, then the data is bad.
-	 */
-	SAFETY_CHECK(overread_count <= (bitsleft >> 3));
-
-	/* Optionally return the actual number of bytes consumed. */
-	if (actual_in_nbytes_ret) {
-		/* Don't count bytes that were refilled but not consumed. */
-		in_next -= (bitsleft >> 3) - overread_count;
-
-		*actual_in_nbytes_ret = in_next - (u8 *)in;
-	}
-
-	/* Optionally return the actual number of bytes written. */
-	if (actual_out_nbytes_ret) {
-		*actual_out_nbytes_ret = out_next - (u8 *)out;
-	} else {
-		if (out_next != out_end)
-			return LIBDEFLATE_SHORT_OUTPUT;
-	}
-	return LIBDEFLATE_SUCCESS;
-}
-
-#undef FUNCNAME
-#undef ATTRIBUTES
-#undef EXTRACT_VARBITS
-#undef EXTRACT_VARBITS8
diff --git a/vendor/core/vendor/libdeflate/lib/deflate_compress.c b/vendor/core/vendor/libdeflate/lib/deflate_compress.c
deleted file mode 100644
index b24087c2..00000000
--- a/vendor/core/vendor/libdeflate/lib/deflate_compress.c
+++ /dev/null
@@ -1,4135 +0,0 @@
-/*
- * deflate_compress.c - a compressor for DEFLATE
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "deflate_compress.h"
-#include "deflate_constants.h"
-
-/******************************************************************************/
-
-/*
- * The following parameters can be changed at build time to customize the
- * compression algorithms slightly:
- *
- * (Note, not all customizable parameters are here.  Some others can be found in
- * libdeflate_alloc_compressor() and in *_matchfinder.h.)
- */
-
-/*
- * If this parameter is defined to 1, then the near-optimal parsing algorithm
- * will be included, and compression levels 10-12 will use it.  This algorithm
- * usually produces a compression ratio significantly better than the other
- * algorithms.  However, it is slow.  If this parameter is defined to 0, then
- * levels 10-12 will be the same as level 9 and will use the lazy2 algorithm.
- */
-#define SUPPORT_NEAR_OPTIMAL_PARSING	1
-
-/*
- * This is the minimum block length that the compressor will use, in
- * uncompressed bytes.  This should be a value below which using shorter blocks
- * is unlikely to be worthwhile, due to the per-block overhead.  This value does
- * not apply to the final block, which may be shorter than this (if the input is
- * shorter, it will have to be), or to the final uncompressed block in a series
- * of uncompressed blocks that cover more than UINT16_MAX bytes.
- *
- * This value is also approximately the amount by which what would otherwise be
- * the second-to-last block is allowed to grow past the soft maximum length in
- * order to avoid having to use a very short final block.
- *
- * Defining a fixed minimum block length is needed in order to guarantee a
- * reasonable upper bound on the compressed size.  It's also needed because our
- * block splitting algorithm doesn't work well on very short blocks.
- */
-#define MIN_BLOCK_LENGTH	5000
-
-/*
- * For the greedy, lazy, lazy2, and near-optimal compressors: This is the soft
- * maximum block length, in uncompressed bytes.  The compressor will try to end
- * blocks at this length, but it may go slightly past it if there is a match
- * that straddles this limit or if the input data ends soon after this limit.
- * This parameter doesn't apply to uncompressed blocks, which the DEFLATE format
- * limits to 65535 bytes.
- *
- * This should be a value above which it is very likely that splitting the block
- * would produce a better compression ratio.  For the near-optimal compressor,
- * increasing/decreasing this parameter will increase/decrease per-compressor
- * memory usage linearly.
- */
-#define SOFT_MAX_BLOCK_LENGTH	300000
-
-/*
- * For the greedy, lazy, and lazy2 compressors: this is the length of the
- * sequence store, which is an array where the compressor temporarily stores
- * matches that it's going to use in the current block.  This value is the
- * maximum number of matches that can be used in a block.  If the sequence store
- * fills up, then the compressor will be forced to end the block early.  This
- * value should be large enough so that this rarely happens, due to the block
- * being ended normally before then.  Increasing/decreasing this value will
- * increase/decrease per-compressor memory usage linearly.
- */
-#define SEQ_STORE_LENGTH	50000
-
-/*
- * For deflate_compress_fastest(): This is the soft maximum block length.
- * deflate_compress_fastest() doesn't use the regular block splitting algorithm;
- * it only ends blocks when they reach FAST_SOFT_MAX_BLOCK_LENGTH bytes or
- * FAST_SEQ_STORE_LENGTH matches.  Therefore, this value should be lower than
- * the regular SOFT_MAX_BLOCK_LENGTH.
- */
-#define FAST_SOFT_MAX_BLOCK_LENGTH	65535
-
-/*
- * For deflate_compress_fastest(): this is the length of the sequence store.
- * This is like SEQ_STORE_LENGTH, but this should be a lower value.
- */
-#define FAST_SEQ_STORE_LENGTH	8192
-
-/*
- * These are the maximum codeword lengths, in bits, the compressor will use for
- * each Huffman code.  The DEFLATE format defines limits for these.  However,
- * further limiting litlen codewords to 14 bits is beneficial, since it has
- * negligible effect on compression ratio but allows some optimizations when
- * outputting bits.  (It allows 4 literals to be written at once rather than 3.)
- */
-#define MAX_LITLEN_CODEWORD_LEN		14
-#define MAX_OFFSET_CODEWORD_LEN		DEFLATE_MAX_OFFSET_CODEWORD_LEN
-#define MAX_PRE_CODEWORD_LEN		DEFLATE_MAX_PRE_CODEWORD_LEN
-
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-
-/* Parameters specific to the near-optimal parsing algorithm */
-
-/*
- * BIT_COST is a scaling factor that allows the near-optimal compressor to
- * consider fractional bit costs when deciding which literal/match sequence to
- * use.  This is useful when the true symbol costs are unknown.  For example, if
- * the compressor thinks that a symbol has 6.5 bits of entropy, it can set its
- * cost to 6.5 bits rather than have to use 6 or 7 bits.  Although in the end
- * each symbol will use a whole number of bits due to the Huffman coding,
- * considering fractional bits can be helpful due to the limited information.
- *
- * BIT_COST should be a power of 2.  A value of 8 or 16 works well.  A higher
- * value isn't very useful since the calculations are approximate anyway.
- *
- * BIT_COST doesn't apply to deflate_flush_block() and
- * deflate_compute_true_cost(), which consider whole bits.
- */
-#define BIT_COST	16
-
-/*
- * The NOSTAT_BITS value for a given alphabet is the number of bits assumed to
- * be needed to output a symbol that was unused in the previous optimization
- * pass.  Assigning a default cost allows the symbol to be used in the next
- * optimization pass.  However, the cost should be relatively high because the
- * symbol probably won't be used very many times (if at all).
- */
-#define LITERAL_NOSTAT_BITS	13
-#define LENGTH_NOSTAT_BITS	13
-#define OFFSET_NOSTAT_BITS	10
-
-/*
- * This is (slightly less than) the maximum number of matches that the
- * near-optimal compressor will cache per block.  This behaves similarly to
- * SEQ_STORE_LENGTH for the other compressors.
- */
-#define MATCH_CACHE_LENGTH	(SOFT_MAX_BLOCK_LENGTH * 5)
-
-#endif /* SUPPORT_NEAR_OPTIMAL_PARSING */
-
-/******************************************************************************/
-
-/* Include the needed matchfinders. */
-#define MATCHFINDER_WINDOW_ORDER	DEFLATE_WINDOW_ORDER
-#include "hc_matchfinder.h"
-#include "ht_matchfinder.h"
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-#  include "bt_matchfinder.h"
-/*
- * This is the maximum number of matches the binary trees matchfinder can find
- * at a single position.  Since the matchfinder never finds more than one match
- * for the same length, presuming one of each possible length is sufficient for
- * an upper bound.  (This says nothing about whether it is worthwhile to
- * consider so many matches; this is just defining the worst case.)
- */
-#define MAX_MATCHES_PER_POS	\
-	(DEFLATE_MAX_MATCH_LEN - DEFLATE_MIN_MATCH_LEN + 1)
-#endif
-
-/*
- * The largest block length we will ever use is when the final block is of
- * length SOFT_MAX_BLOCK_LENGTH + MIN_BLOCK_LENGTH - 1, or when any block is of
- * length SOFT_MAX_BLOCK_LENGTH + 1 + DEFLATE_MAX_MATCH_LEN.  The latter case
- * occurs when the lazy2 compressor chooses two literals and a maximum-length
- * match, starting at SOFT_MAX_BLOCK_LENGTH - 1.
- */
-#define MAX_BLOCK_LENGTH	\
-	MAX(SOFT_MAX_BLOCK_LENGTH + MIN_BLOCK_LENGTH - 1,	\
-	    SOFT_MAX_BLOCK_LENGTH + 1 + DEFLATE_MAX_MATCH_LEN)
-
-static forceinline void
-check_buildtime_parameters(void)
-{
-	/*
-	 * Verify that MIN_BLOCK_LENGTH is being honored, as
-	 * libdeflate_deflate_compress_bound() depends on it.
-	 */
-	STATIC_ASSERT(SOFT_MAX_BLOCK_LENGTH >= MIN_BLOCK_LENGTH);
-	STATIC_ASSERT(FAST_SOFT_MAX_BLOCK_LENGTH >= MIN_BLOCK_LENGTH);
-	STATIC_ASSERT(SEQ_STORE_LENGTH * DEFLATE_MIN_MATCH_LEN >=
-		      MIN_BLOCK_LENGTH);
-	STATIC_ASSERT(FAST_SEQ_STORE_LENGTH * HT_MATCHFINDER_MIN_MATCH_LEN >=
-		      MIN_BLOCK_LENGTH);
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-	STATIC_ASSERT(MIN_BLOCK_LENGTH * MAX_MATCHES_PER_POS <=
-		      MATCH_CACHE_LENGTH);
-#endif
-
-	/* The definition of MAX_BLOCK_LENGTH assumes this. */
-	STATIC_ASSERT(FAST_SOFT_MAX_BLOCK_LENGTH <= SOFT_MAX_BLOCK_LENGTH);
-
-	/* Verify that the sequence stores aren't uselessly large. */
-	STATIC_ASSERT(SEQ_STORE_LENGTH * DEFLATE_MIN_MATCH_LEN <=
-		      SOFT_MAX_BLOCK_LENGTH + MIN_BLOCK_LENGTH);
-	STATIC_ASSERT(FAST_SEQ_STORE_LENGTH * HT_MATCHFINDER_MIN_MATCH_LEN <=
-		      FAST_SOFT_MAX_BLOCK_LENGTH + MIN_BLOCK_LENGTH);
-
-	/* Verify that the maximum codeword lengths are valid. */
-	STATIC_ASSERT(
-		MAX_LITLEN_CODEWORD_LEN <= DEFLATE_MAX_LITLEN_CODEWORD_LEN);
-	STATIC_ASSERT(
-		MAX_OFFSET_CODEWORD_LEN <= DEFLATE_MAX_OFFSET_CODEWORD_LEN);
-	STATIC_ASSERT(
-		MAX_PRE_CODEWORD_LEN <= DEFLATE_MAX_PRE_CODEWORD_LEN);
-	STATIC_ASSERT(
-		(1U << MAX_LITLEN_CODEWORD_LEN) >= DEFLATE_NUM_LITLEN_SYMS);
-	STATIC_ASSERT(
-		(1U << MAX_OFFSET_CODEWORD_LEN) >= DEFLATE_NUM_OFFSET_SYMS);
-	STATIC_ASSERT(
-		(1U << MAX_PRE_CODEWORD_LEN) >= DEFLATE_NUM_PRECODE_SYMS);
-}
-
-/******************************************************************************/
-
-/* Table: length slot => length slot base value */
-static const u32 deflate_length_slot_base[] = {
-	3,    4,    5,    6,    7,    8,    9,    10,
-	11,   13,   15,   17,   19,   23,   27,   31,
-	35,   43,   51,   59,   67,   83,   99,   115,
-	131,  163,  195,  227,  258,
-};
-
-/* Table: length slot => number of extra length bits */
-static const u8 deflate_extra_length_bits[] = {
-	0,    0,    0,    0,    0,    0,    0,    0,
-	1,    1,    1,    1,    2,    2,    2,    2,
-	3,    3,    3,    3,    4,    4,    4,    4,
-	5,    5,    5,    5,    0,
-};
-
-/* Table: offset slot => offset slot base value */
-static const u32 deflate_offset_slot_base[] = {
-	1,     2,     3,     4,     5,     7,     9,     13,
-	17,    25,    33,    49,    65,    97,    129,   193,
-	257,   385,   513,   769,   1025,  1537,  2049,  3073,
-	4097,  6145,  8193,  12289, 16385, 24577,
-};
-
-/* Table: offset slot => number of extra offset bits */
-static const u8 deflate_extra_offset_bits[] = {
-	0,     0,     0,     0,     1,     1,     2,     2,
-	3,     3,     4,     4,     5,     5,     6,     6,
-	7,     7,     8,     8,     9,     9,     10,    10,
-	11,    11,    12,    12,    13,    13,
-};
-
-/* Table: length => length slot */
-static const u8 deflate_length_slot[DEFLATE_MAX_MATCH_LEN + 1] = {
-	0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12,
-	12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16,
-	16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18,
-	18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-	20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-	21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-	22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-	23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-	24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-	26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-	27, 27, 28,
-};
-
-/*
- * Table: 'offset - 1 => offset_slot' for offset <= 256.
- * This was generated by scripts/gen_offset_slot_map.py.
- */
-static const u8 deflate_offset_slot[256] = {
-	0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
-	8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
-	10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
-	11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-};
-
-/* The order in which precode codeword lengths are stored */
-static const u8 deflate_precode_lens_permutation[DEFLATE_NUM_PRECODE_SYMS] = {
-	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
-};
-
-/* Table: precode symbol => number of extra bits */
-static const u8 deflate_extra_precode_bits[DEFLATE_NUM_PRECODE_SYMS] = {
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7
-};
-
-/* Codewords for the DEFLATE Huffman codes */
-struct deflate_codewords {
-	u32 litlen[DEFLATE_NUM_LITLEN_SYMS];
-	u32 offset[DEFLATE_NUM_OFFSET_SYMS];
-};
-
-/*
- * Codeword lengths (in bits) for the DEFLATE Huffman codes.
- * A zero length means the corresponding symbol had zero frequency.
- */
-struct deflate_lens {
-	u8 litlen[DEFLATE_NUM_LITLEN_SYMS];
-	u8 offset[DEFLATE_NUM_OFFSET_SYMS];
-};
-
-/* Codewords and lengths for the DEFLATE Huffman codes */
-struct deflate_codes {
-	struct deflate_codewords codewords;
-	struct deflate_lens lens;
-};
-
-/* Symbol frequency counters for the DEFLATE Huffman codes */
-struct deflate_freqs {
-	u32 litlen[DEFLATE_NUM_LITLEN_SYMS];
-	u32 offset[DEFLATE_NUM_OFFSET_SYMS];
-};
-
-/*
- * Represents a run of literals followed by a match or end-of-block.  This
- * struct is needed to temporarily store items chosen by the parser, since items
- * cannot be written until all items for the block have been chosen and the
- * block's Huffman codes have been computed.
- */
-struct deflate_sequence {
-
-	/*
-	 * Bits 0..22: the number of literals in this run.  This may be 0 and
-	 * can be at most MAX_BLOCK_LENGTH.  The literals are not stored
-	 * explicitly in this structure; instead, they are read directly from
-	 * the uncompressed data.
-	 *
-	 * Bits 23..31: the length of the match which follows the literals, or 0
-	 * if this literal run was the last in the block, so there is no match
-	 * which follows it.
-	 */
-#define SEQ_LENGTH_SHIFT 23
-#define SEQ_LITRUNLEN_MASK (((u32)1 << SEQ_LENGTH_SHIFT) - 1)
-	u32 litrunlen_and_length;
-
-	/*
-	 * If 'length' doesn't indicate end-of-block, then this is the offset of
-	 * the match which follows the literals.
-	 */
-	u16 offset;
-
-	/*
-	 * If 'length' doesn't indicate end-of-block, then this is the offset
-	 * slot of the match which follows the literals.
-	 */
-	u16 offset_slot;
-};
-
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-
-/* Costs for the near-optimal parsing algorithm */
-struct deflate_costs {
-
-	/* The cost to output each possible literal */
-	u32 literal[DEFLATE_NUM_LITERALS];
-
-	/* The cost to output each possible match length */
-	u32 length[DEFLATE_MAX_MATCH_LEN + 1];
-
-	/* The cost to output a match offset of each possible offset slot */
-	u32 offset_slot[DEFLATE_NUM_OFFSET_SYMS];
-};
-
-/*
- * This structure represents a byte position in the input data and a node in the
- * graph of possible match/literal choices for the current block.
- *
- * Logically, each incoming edge to this node is labeled with a literal or a
- * match that can be taken to reach this position from an earlier position; and
- * each outgoing edge from this node is labeled with a literal or a match that
- * can be taken to advance from this position to a later position.
- *
- * But these "edges" are actually stored elsewhere (in 'match_cache').  Here we
- * associate with each node just two pieces of information:
- *
- *	'cost_to_end' is the minimum cost to reach the end of the block from
- *	this position.
- *
- *	'item' represents the literal or match that must be chosen from here to
- *	reach the end of the block with the minimum cost.  Equivalently, this
- *	can be interpreted as the label of the outgoing edge on the minimum-cost
- *	path to the "end of block" node from this node.
- */
-struct deflate_optimum_node {
-
-	u32 cost_to_end;
-
-	/*
-	 * Notes on the match/literal representation used here:
-	 *
-	 *	The low bits of 'item' are the length: 1 if this is a literal,
-	 *	or the match length if this is a match.
-	 *
-	 *	The high bits of 'item' are the actual literal byte if this is a
-	 *	literal, or the match offset if this is a match.
-	 */
-#define OPTIMUM_OFFSET_SHIFT 9
-#define OPTIMUM_LEN_MASK (((u32)1 << OPTIMUM_OFFSET_SHIFT) - 1)
-	u32 item;
-
-};
-
-#endif /* SUPPORT_NEAR_OPTIMAL_PARSING */
-
-/* Block split statistics.  See "Block splitting algorithm" below. */
-#define NUM_LITERAL_OBSERVATION_TYPES 8
-#define NUM_MATCH_OBSERVATION_TYPES 2
-#define NUM_OBSERVATION_TYPES (NUM_LITERAL_OBSERVATION_TYPES + \
-			       NUM_MATCH_OBSERVATION_TYPES)
-#define NUM_OBSERVATIONS_PER_BLOCK_CHECK 512
-struct block_split_stats {
-	u32 new_observations[NUM_OBSERVATION_TYPES];
-	u32 observations[NUM_OBSERVATION_TYPES];
-	u32 num_new_observations;
-	u32 num_observations;
-};
-
-struct deflate_output_bitstream;
-
-/* The main DEFLATE compressor structure */
-struct libdeflate_compressor {
-
-	/* Pointer to the compress() implementation chosen at allocation time */
-	void (*impl)(struct libdeflate_compressor *restrict c, const u8 *in,
-		     size_t in_nbytes, struct deflate_output_bitstream *os);
-
-	/* The free() function for this struct, chosen at allocation time */
-	free_func_t free_func;
-
-	/* The compression level with which this compressor was created */
-	unsigned compression_level;
-
-	/* Anything of this size or less we won't bother trying to compress. */
-	size_t max_passthrough_size;
-
-	/*
-	 * The maximum search depth: consider at most this many potential
-	 * matches at each position
-	 */
-	u32 max_search_depth;
-
-	/*
-	 * The "nice" match length: if a match of this length is found, choose
-	 * it immediately without further consideration
-	 */
-	u32 nice_match_length;
-
-	/* Frequency counters for the current block */
-	struct deflate_freqs freqs;
-
-	/* Block split statistics for the current block */
-	struct block_split_stats split_stats;
-
-	/* Dynamic Huffman codes for the current block */
-	struct deflate_codes codes;
-
-	/* The static Huffman codes defined by the DEFLATE format */
-	struct deflate_codes static_codes;
-
-	/* Temporary space for block flushing */
-	union {
-		/* Information about the precode */
-		struct {
-			u32 freqs[DEFLATE_NUM_PRECODE_SYMS];
-			u32 codewords[DEFLATE_NUM_PRECODE_SYMS];
-			u8 lens[DEFLATE_NUM_PRECODE_SYMS];
-			unsigned items[DEFLATE_NUM_LITLEN_SYMS +
-				       DEFLATE_NUM_OFFSET_SYMS];
-			unsigned num_litlen_syms;
-			unsigned num_offset_syms;
-			unsigned num_explicit_lens;
-			unsigned num_items;
-		} precode;
-		/*
-		 * The "full" length codewords.  Used only after the information
-		 * in 'precode' is no longer needed.
-		 */
-		struct {
-			u32 codewords[DEFLATE_MAX_MATCH_LEN + 1];
-			u8 lens[DEFLATE_MAX_MATCH_LEN + 1];
-		} length;
-	} o;
-
-	union {
-		/* Data for greedy or lazy parsing */
-		struct {
-			/* Hash chains matchfinder */
-			struct hc_matchfinder hc_mf;
-
-			/* Matches and literals chosen for the current block */
-			struct deflate_sequence sequences[SEQ_STORE_LENGTH + 1];
-
-		} g; /* (g)reedy */
-
-		/* Data for fastest parsing */
-		struct {
-			/* Hash table matchfinder */
-			struct ht_matchfinder ht_mf;
-
-			/* Matches and literals chosen for the current block */
-			struct deflate_sequence sequences[
-						FAST_SEQ_STORE_LENGTH + 1];
-
-		} f; /* (f)astest */
-
-	#if SUPPORT_NEAR_OPTIMAL_PARSING
-		/* Data for near-optimal parsing */
-		struct {
-
-			/* Binary tree matchfinder */
-			struct bt_matchfinder bt_mf;
-
-			/*
-			 * Cached matches for the current block.  This array
-			 * contains the matches that were found at each position
-			 * in the block.  Specifically, for each position, there
-			 * is a list of matches found at that position, if any,
-			 * sorted by strictly increasing length.  In addition,
-			 * following the matches for each position, there is a
-			 * special 'struct lz_match' whose 'length' member
-			 * contains the number of matches found at that
-			 * position, and whose 'offset' member contains the
-			 * literal at that position.
-			 *
-			 * Note: in rare cases, there will be a very high number
-			 * of matches in the block and this array will overflow.
-			 * If this happens, we force the end of the current
-			 * block.  MATCH_CACHE_LENGTH is the length at which we
-			 * actually check for overflow.  The extra slots beyond
-			 * this are enough to absorb the worst case overflow,
-			 * which occurs if starting at
-			 * &match_cache[MATCH_CACHE_LENGTH - 1], we write
-			 * MAX_MATCHES_PER_POS matches and a match count header,
-			 * then skip searching for matches at
-			 * 'DEFLATE_MAX_MATCH_LEN - 1' positions and write the
-			 * match count header for each.
-			 */
-			struct lz_match match_cache[MATCH_CACHE_LENGTH +
-						    MAX_MATCHES_PER_POS +
-						    DEFLATE_MAX_MATCH_LEN - 1];
-
-			/*
-			 * Array of nodes, one per position, for running the
-			 * minimum-cost path algorithm.
-			 *
-			 * This array must be large enough to accommodate the
-			 * worst-case number of nodes, which is MAX_BLOCK_LENGTH
-			 * plus 1 for the end-of-block node.
-			 */
-			struct deflate_optimum_node optimum_nodes[
-				MAX_BLOCK_LENGTH + 1];
-
-			/* The current cost model being used */
-			struct deflate_costs costs;
-
-			/* Saved cost model */
-			struct deflate_costs costs_saved;
-
-			/*
-			 * A table that maps match offset to offset slot.  This
-			 * differs from deflate_offset_slot[] in that this is a
-			 * full map, not a condensed one.  The full map is more
-			 * appropriate for the near-optimal parser, since the
-			 * near-optimal parser does more offset => offset_slot
-			 * translations, it doesn't intersperse them with
-			 * matchfinding (so cache evictions are less of a
-			 * concern), and it uses more memory anyway.
-			 */
-			u8 offset_slot_full[DEFLATE_MAX_MATCH_OFFSET + 1];
-
-			/* Literal/match statistics saved from previous block */
-			u32 prev_observations[NUM_OBSERVATION_TYPES];
-			u32 prev_num_observations;
-
-			/*
-			 * Approximate match length frequencies based on a
-			 * greedy parse, gathered during matchfinding.  This is
-			 * used for setting the initial symbol costs.
-			 */
-			u32 new_match_len_freqs[DEFLATE_MAX_MATCH_LEN + 1];
-			u32 match_len_freqs[DEFLATE_MAX_MATCH_LEN + 1];
-
-			/*
-			 * The maximum number of optimization passes
-			 * (min-cost path searches) per block.
-			 * Larger values = more compression.
-			 */
-			unsigned max_optim_passes;
-
-			/*
-			 * If an optimization pass improves the cost by fewer
-			 * than this number of bits, then optimization will stop
-			 * early, before max_optim_passes has been reached.
-			 * Smaller values = more compression.
-			 */
-			u32 min_improvement_to_continue;
-
-			/*
-			 * The minimum number of bits that would need to be
-			 * saved for it to be considered worth the time to
-			 * regenerate and use the min-cost path from a previous
-			 * optimization pass, in the case where the final
-			 * optimization pass actually increased the cost.
-			 * Smaller values = more compression.
-			 */
-			u32 min_bits_to_use_nonfinal_path;
-
-			/*
-			 * The maximum block length, in uncompressed bytes, at
-			 * which to find and consider the optimal match/literal
-			 * list for the static Huffman codes.  This strategy
-			 * improves the compression ratio produced by static
-			 * Huffman blocks and can discover more cases in which
-			 * static blocks are worthwhile.  This helps mostly with
-			 * small blocks, hence why this parameter is a max_len.
-			 *
-			 * Above this block length, static Huffman blocks are
-			 * only used opportunistically.  I.e. a static Huffman
-			 * block is only used if a static block using the same
-			 * match/literal list as the optimized dynamic block
-			 * happens to be cheaper than the dynamic block itself.
-			 */
-			u32 max_len_to_optimize_static_block;
-
-		} n; /* (n)ear-optimal */
-	#endif /* SUPPORT_NEAR_OPTIMAL_PARSING */
-
-	} p; /* (p)arser */
-};
-
-/*
- * The type for the bitbuffer variable, which temporarily holds bits that are
- * being packed into bytes and written to the output buffer.  For best
- * performance, this should have size equal to a machine word.
- */
-typedef machine_word_t bitbuf_t;
-
-/*
- * The capacity of the bitbuffer, in bits.  This is 1 less than the real size,
- * in order to avoid undefined behavior when doing bitbuf >>= bitcount & ~7.
- */
-#define BITBUF_NBITS	(8 * sizeof(bitbuf_t) - 1)
-
-/*
- * Can the specified number of bits always be added to 'bitbuf' after any
- * pending bytes have been flushed?  There can be up to 7 bits remaining after a
- * flush, so the count must not exceed BITBUF_NBITS after adding 'n' more bits.
- */
-#define CAN_BUFFER(n)	(7 + (n) <= BITBUF_NBITS)
-
-/*
- * Structure to keep track of the current state of sending bits to the
- * compressed output buffer
- */
-struct deflate_output_bitstream {
-
-	/* Bits that haven't yet been written to the output buffer */
-	bitbuf_t bitbuf;
-
-	/*
-	 * Number of bits currently held in @bitbuf.  This can be between 0 and
-	 * BITBUF_NBITS in general, or between 0 and 7 after a flush.
-	 */
-	unsigned bitcount;
-
-	/*
-	 * Pointer to the position in the output buffer at which the next byte
-	 * should be written
-	 */
-	u8 *next;
-
-	/* Pointer to the end of the output buffer */
-	u8 *end;
-
-	/* true if the output buffer ran out of space */
-	bool overflow;
-};
-
-/*
- * Add some bits to the bitbuffer variable of the output bitstream.  The caller
- * must ensure that 'bitcount + n <= BITBUF_NBITS', by calling FLUSH_BITS()
- * frequently enough.
- */
-#define ADD_BITS(bits, n)			\
-do {						\
-	bitbuf |= (bitbuf_t)(bits) << bitcount;	\
-	bitcount += (n);			\
-	ASSERT(bitcount <= BITBUF_NBITS);	\
-} while (0)
-
-/*
- * Flush bits from the bitbuffer variable to the output buffer.  After this, the
- * bitbuffer will contain at most 7 bits (a partial byte).
- *
- * Since deflate_flush_block() verified ahead of time that there is enough space
- * remaining before actually writing the block, it's guaranteed that out_next
- * won't exceed os->end.  However, there might not be enough space remaining to
- * flush a whole word, even though that's fastest.  Therefore, flush a whole
- * word if there is space for it, otherwise flush a byte at a time.
- */
-#define FLUSH_BITS()							\
-do {									\
-	if (UNALIGNED_ACCESS_IS_FAST && likely(out_next < out_fast_end)) { \
-		/* Flush a whole word (branchlessly). */		\
-		put_unaligned_leword(bitbuf, out_next);			\
-		bitbuf >>= bitcount & ~7;				\
-		out_next += bitcount >> 3;				\
-		bitcount &= 7;						\
-	} else {							\
-		/* Flush a byte at a time. */				\
-		while (bitcount >= 8) {					\
-			ASSERT(out_next < os->end);			\
-			*out_next++ = bitbuf;				\
-			bitcount -= 8;					\
-			bitbuf >>= 8;					\
-		}							\
-	}								\
-} while (0)
-
-/*
- * Given the binary tree node A[subtree_idx] whose children already satisfy the
- * maxheap property, swap the node with its greater child until it is greater
- * than or equal to both of its children, so that the maxheap property is
- * satisfied in the subtree rooted at A[subtree_idx].  'A' uses 1-based indices.
- */
-static void
-heapify_subtree(u32 A[], unsigned length, unsigned subtree_idx)
-{
-	unsigned parent_idx;
-	unsigned child_idx;
-	u32 v;
-
-	v = A[subtree_idx];
-	parent_idx = subtree_idx;
-	while ((child_idx = parent_idx * 2) <= length) {
-		if (child_idx < length && A[child_idx + 1] > A[child_idx])
-			child_idx++;
-		if (v >= A[child_idx])
-			break;
-		A[parent_idx] = A[child_idx];
-		parent_idx = child_idx;
-	}
-	A[parent_idx] = v;
-}
-
-/*
- * Rearrange the array 'A' so that it satisfies the maxheap property.
- * 'A' uses 1-based indices, so the children of A[i] are A[i*2] and A[i*2 + 1].
- */
-static void
-heapify_array(u32 A[], unsigned length)
-{
-	unsigned subtree_idx;
-
-	for (subtree_idx = length / 2; subtree_idx >= 1; subtree_idx--)
-		heapify_subtree(A, length, subtree_idx);
-}
-
-/*
- * Sort the array 'A', which contains 'length' unsigned 32-bit integers.
- *
- * Note: name this function heap_sort() instead of heapsort() to avoid colliding
- * with heapsort() from stdlib.h on BSD-derived systems.
- */
-static void
-heap_sort(u32 A[], unsigned length)
-{
-	A--; /* Use 1-based indices  */
-
-	heapify_array(A, length);
-
-	while (length >= 2) {
-		u32 tmp = A[length];
-
-		A[length] = A[1];
-		A[1] = tmp;
-		length--;
-		heapify_subtree(A, length, 1);
-	}
-}
-
-#define NUM_SYMBOL_BITS 10
-#define NUM_FREQ_BITS	(32 - NUM_SYMBOL_BITS)
-#define SYMBOL_MASK	((1 << NUM_SYMBOL_BITS) - 1)
-#define FREQ_MASK	(~SYMBOL_MASK)
-
-#define GET_NUM_COUNTERS(num_syms)	(num_syms)
-
-/*
- * Sort the symbols primarily by frequency and secondarily by symbol value.
- * Discard symbols with zero frequency and fill in an array with the remaining
- * symbols, along with their frequencies.  The low NUM_SYMBOL_BITS bits of each
- * array entry will contain the symbol value, and the remaining bits will
- * contain the frequency.
- *
- * @num_syms
- *	Number of symbols in the alphabet, at most 1 << NUM_SYMBOL_BITS.
- *
- * @freqs[num_syms]
- *	Frequency of each symbol, summing to at most (1 << NUM_FREQ_BITS) - 1.
- *
- * @lens[num_syms]
- *	An array that eventually will hold the length of each codeword.  This
- *	function only fills in the codeword lengths for symbols that have zero
- *	frequency, which are not well defined per se but will be set to 0.
- *
- * @symout[num_syms]
- *	The output array, described above.
- *
- * Returns the number of entries in 'symout' that were filled.  This is the
- * number of symbols that have nonzero frequency.
- */
-static unsigned
-sort_symbols(unsigned num_syms, const u32 freqs[], u8 lens[], u32 symout[])
-{
-	unsigned sym;
-	unsigned i;
-	unsigned num_used_syms;
-	unsigned num_counters;
-	unsigned counters[GET_NUM_COUNTERS(DEFLATE_MAX_NUM_SYMS)];
-
-	/*
-	 * We use heapsort, but with an added optimization.  Since often most
-	 * symbol frequencies are low, we first do a count sort using a limited
-	 * number of counters.  High frequencies are counted in the last
-	 * counter, and only they will be sorted with heapsort.
-	 *
-	 * Note: with more symbols, it is generally beneficial to have more
-	 * counters.  About 1 counter per symbol seems fastest.
-	 */
-
-	num_counters = GET_NUM_COUNTERS(num_syms);
-
-	memset(counters, 0, num_counters * sizeof(counters[0]));
-
-	/* Count the frequencies. */
-	for (sym = 0; sym < num_syms; sym++)
-		counters[MIN(freqs[sym], num_counters - 1)]++;
-
-	/*
-	 * Make the counters cumulative, ignoring the zero-th, which counted
-	 * symbols with zero frequency.  As a side effect, this calculates the
-	 * number of symbols with nonzero frequency.
-	 */
-	num_used_syms = 0;
-	for (i = 1; i < num_counters; i++) {
-		unsigned count = counters[i];
-
-		counters[i] = num_used_syms;
-		num_used_syms += count;
-	}
-
-	/*
-	 * Sort nonzero-frequency symbols using the counters.  At the same time,
-	 * set the codeword lengths of zero-frequency symbols to 0.
-	 */
-	for (sym = 0; sym < num_syms; sym++) {
-		u32 freq = freqs[sym];
-
-		if (freq != 0) {
-			symout[counters[MIN(freq, num_counters - 1)]++] =
-				sym | (freq << NUM_SYMBOL_BITS);
-		} else {
-			lens[sym] = 0;
-		}
-	}
-
-	/* Sort the symbols counted in the last counter. */
-	heap_sort(symout + counters[num_counters - 2],
-		  counters[num_counters - 1] - counters[num_counters - 2]);
-
-	return num_used_syms;
-}
-
-/*
- * Build a Huffman tree.
- *
- * This is an optimized implementation that
- *	(a) takes advantage of the frequencies being already sorted;
- *	(b) only generates non-leaf nodes, since the non-leaf nodes of a Huffman
- *	    tree are sufficient to generate a canonical code;
- *	(c) Only stores parent pointers, not child pointers;
- *	(d) Produces the nodes in the same memory used for input frequency
- *	    information.
- *
- * Array 'A', which contains 'sym_count' entries, is used for both input and
- * output.  For this function, 'sym_count' must be at least 2.
- *
- * For input, the array must contain the frequencies of the symbols, sorted in
- * increasing order.  Specifically, each entry must contain a frequency left
- * shifted by NUM_SYMBOL_BITS bits.  Any data in the low NUM_SYMBOL_BITS bits of
- * the entries will be ignored by this function.  Although these bits will, in
- * fact, contain the symbols that correspond to the frequencies, this function
- * is concerned with frequencies only and keeps the symbols as-is.
- *
- * For output, this function will produce the non-leaf nodes of the Huffman
- * tree.  These nodes will be stored in the first (sym_count - 1) entries of the
- * array.  Entry A[sym_count - 2] will represent the root node.  Each other node
- * will contain the zero-based index of its parent node in 'A', left shifted by
- * NUM_SYMBOL_BITS bits.  The low NUM_SYMBOL_BITS bits of each entry in A will
- * be kept as-is.  Again, note that although these low bits will, in fact,
- * contain a symbol value, this symbol will have *no relationship* with the
- * Huffman tree node that happens to occupy the same slot.  This is because this
- * implementation only generates the non-leaf nodes of the tree.
- */
-static void
-build_tree(u32 A[], unsigned sym_count)
-{
-	const unsigned last_idx = sym_count - 1;
-
-	/* Index of the next lowest frequency leaf that still needs a parent */
-	unsigned i = 0;
-
-	/*
-	 * Index of the next lowest frequency non-leaf that still needs a
-	 * parent, or 'e' if there is currently no such node
-	 */
-	unsigned b = 0;
-
-	/* Index of the next spot for a non-leaf (will overwrite a leaf) */
-	unsigned e = 0;
-
-	do {
-		u32 new_freq;
-
-		/*
-		 * Select the next two lowest frequency nodes among the leaves
-		 * A[i] and non-leaves A[b], and create a new node A[e] to be
-		 * their parent.  Set the new node's frequency to the sum of the
-		 * frequencies of its two children.
-		 *
-		 * Usually the next two lowest frequency nodes are of the same
-		 * type (leaf or non-leaf), so check those cases first.
-		 */
-		if (i + 1 <= last_idx &&
-		    (b == e || (A[i + 1] & FREQ_MASK) <= (A[b] & FREQ_MASK))) {
-			/* Two leaves */
-			new_freq = (A[i] & FREQ_MASK) + (A[i + 1] & FREQ_MASK);
-			i += 2;
-		} else if (b + 2 <= e &&
-			   (i > last_idx ||
-			    (A[b + 1] & FREQ_MASK) < (A[i] & FREQ_MASK))) {
-			/* Two non-leaves */
-			new_freq = (A[b] & FREQ_MASK) + (A[b + 1] & FREQ_MASK);
-			A[b] = (e << NUM_SYMBOL_BITS) | (A[b] & SYMBOL_MASK);
-			A[b + 1] = (e << NUM_SYMBOL_BITS) |
-				   (A[b + 1] & SYMBOL_MASK);
-			b += 2;
-		} else {
-			/* One leaf and one non-leaf */
-			new_freq = (A[i] & FREQ_MASK) + (A[b] & FREQ_MASK);
-			A[b] = (e << NUM_SYMBOL_BITS) | (A[b] & SYMBOL_MASK);
-			i++;
-			b++;
-		}
-		A[e] = new_freq | (A[e] & SYMBOL_MASK);
-		/*
-		 * A binary tree with 'n' leaves has 'n - 1' non-leaves, so the
-		 * tree is complete once we've created 'n - 1' non-leaves.
-		 */
-	} while (++e < last_idx);
-}
-
-/*
- * Given the stripped-down Huffman tree constructed by build_tree(), determine
- * the number of codewords that should be assigned each possible length, taking
- * into account the length-limited constraint.
- *
- * @A
- *	The array produced by build_tree(), containing parent index information
- *	for the non-leaf nodes of the Huffman tree.  Each entry in this array is
- *	a node; a node's parent always has a greater index than that node
- *	itself.  This function will overwrite the parent index information in
- *	this array, so essentially it will destroy the tree.  However, the data
- *	in the low NUM_SYMBOL_BITS of each entry will be preserved.
- *
- * @root_idx
- *	The 0-based index of the root node in 'A', and consequently one less
- *	than the number of tree node entries in 'A'.  (Or, really 2 less than
- *	the actual length of 'A'.)
- *
- * @len_counts
- *	An array of length ('max_codeword_len' + 1) in which the number of
- *	codewords having each length <= max_codeword_len will be returned.
- *
- * @max_codeword_len
- *	The maximum permissible codeword length.
- */
-static void
-compute_length_counts(u32 A[], unsigned root_idx, unsigned len_counts[],
-		      unsigned max_codeword_len)
-{
-	unsigned len;
-	int node;
-
-	/*
-	 * The key observations are:
-	 *
-	 * (1) We can traverse the non-leaf nodes of the tree, always visiting a
-	 *     parent before its children, by simply iterating through the array
-	 *     in reverse order.  Consequently, we can compute the depth of each
-	 *     node in one pass, overwriting the parent indices with depths.
-	 *
-	 * (2) We can initially assume that in the real Huffman tree, both
-	 *     children of the root are leaves.  This corresponds to two
-	 *     codewords of length 1.  Then, whenever we visit a (non-leaf) node
-	 *     during the traversal, we modify this assumption to account for
-	 *     the current node *not* being a leaf, but rather its two children
-	 *     being leaves.  This causes the loss of one codeword for the
-	 *     current depth and the addition of two codewords for the current
-	 *     depth plus one.
-	 *
-	 * (3) We can handle the length-limited constraint fairly easily by
-	 *     simply using the largest length available when a depth exceeds
-	 *     max_codeword_len.
-	 */
-
-	for (len = 0; len <= max_codeword_len; len++)
-		len_counts[len] = 0;
-	len_counts[1] = 2;
-
-	/* Set the root node's depth to 0. */
-	A[root_idx] &= SYMBOL_MASK;
-
-	for (node = root_idx - 1; node >= 0; node--) {
-
-		/* Calculate the depth of this node. */
-
-		unsigned parent = A[node] >> NUM_SYMBOL_BITS;
-		unsigned parent_depth = A[parent] >> NUM_SYMBOL_BITS;
-		unsigned depth = parent_depth + 1;
-
-		/*
-		 * Set the depth of this node so that it is available when its
-		 * children (if any) are processed.
-		 */
-		A[node] = (A[node] & SYMBOL_MASK) | (depth << NUM_SYMBOL_BITS);
-
-		/*
-		 * If needed, decrease the length to meet the length-limited
-		 * constraint.  This is not the optimal method for generating
-		 * length-limited Huffman codes!  But it should be good enough.
-		 */
-		if (depth >= max_codeword_len) {
-			depth = max_codeword_len;
-			do {
-				depth--;
-			} while (len_counts[depth] == 0);
-		}
-
-		/*
-		 * Account for the fact that we have a non-leaf node at the
-		 * current depth.
-		 */
-		len_counts[depth]--;
-		len_counts[depth + 1] += 2;
-	}
-}
-
-/*
- * DEFLATE uses bit-reversed codewords, so we must bit-reverse the codewords
- * after generating them.  All codewords have length <= 16 bits.  If the CPU has
- * a bit-reversal instruction, then that is the fastest method.  Otherwise the
- * fastest method is to reverse the bits in each of the two bytes using a table.
- * The table method is slightly faster than using bitwise operations to flip
- * adjacent 1, 2, 4, and then 8-bit fields, even if 2 to 4 codewords are packed
- * into a machine word and processed together using that method.
- */
-
-#ifdef rbit32
-static forceinline u32 reverse_codeword(u32 codeword, u8 len)
-{
-	return rbit32(codeword) >> ((32 - len) & 31);
-}
-#else
-/* Generated by scripts/gen_bitreverse_tab.py */
-static const u8 bitreverse_tab[256] = {
-	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
-	0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
-	0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
-	0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
-	0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
-	0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
-	0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
-	0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
-	0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
-	0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
-	0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
-	0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
-	0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
-	0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
-	0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
-	0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
-	0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
-};
-
-static forceinline u32 reverse_codeword(u32 codeword, u8 len)
-{
-	STATIC_ASSERT(DEFLATE_MAX_CODEWORD_LEN <= 16);
-	codeword = ((u32)bitreverse_tab[codeword & 0xff] << 8) |
-		   bitreverse_tab[codeword >> 8];
-	return codeword >> (16 - len);
-}
-#endif /* !rbit32 */
-
-/*
- * Generate the codewords for a canonical Huffman code.
- *
- * @A
- *	The output array for codewords.  In addition, initially this
- *	array must contain the symbols, sorted primarily by frequency and
- *	secondarily by symbol value, in the low NUM_SYMBOL_BITS bits of
- *	each entry.
- *
- * @len
- *	Output array for codeword lengths.
- *
- * @len_counts
- *	An array that provides the number of codewords that will have
- *	each possible length <= max_codeword_len.
- *
- * @max_codeword_len
- *	Maximum length, in bits, of each codeword.
- *
- * @num_syms
- *	Number of symbols in the alphabet, including symbols with zero
- *	frequency.  This is the length of the 'A' and 'len' arrays.
- */
-static void
-gen_codewords(u32 A[], u8 lens[], const unsigned len_counts[],
-	      unsigned max_codeword_len, unsigned num_syms)
-{
-	u32 next_codewords[DEFLATE_MAX_CODEWORD_LEN + 1];
-	unsigned i;
-	unsigned len;
-	unsigned sym;
-
-	/*
-	 * Given the number of codewords that will have each length, assign
-	 * codeword lengths to symbols.  We do this by assigning the lengths in
-	 * decreasing order to the symbols sorted primarily by increasing
-	 * frequency and secondarily by increasing symbol value.
-	 */
-	for (i = 0, len = max_codeword_len; len >= 1; len--) {
-		unsigned count = len_counts[len];
-
-		while (count--)
-			lens[A[i++] & SYMBOL_MASK] = len;
-	}
-
-	/*
-	 * Generate the codewords themselves.  We initialize the
-	 * 'next_codewords' array to provide the lexicographically first
-	 * codeword of each length, then assign codewords in symbol order.  This
-	 * produces a canonical code.
-	 */
-	next_codewords[0] = 0;
-	next_codewords[1] = 0;
-	for (len = 2; len <= max_codeword_len; len++)
-		next_codewords[len] =
-			(next_codewords[len - 1] + len_counts[len - 1]) << 1;
-
-	for (sym = 0; sym < num_syms; sym++) {
-		/* DEFLATE requires bit-reversed codewords. */
-		A[sym] = reverse_codeword(next_codewords[lens[sym]]++,
-					  lens[sym]);
-	}
-}
-
-/*
- * ---------------------------------------------------------------------
- *			deflate_make_huffman_code()
- * ---------------------------------------------------------------------
- *
- * Given an alphabet and the frequency of each symbol in it, construct a
- * length-limited canonical Huffman code.
- *
- * @num_syms
- *	The number of symbols in the alphabet.  The symbols are the integers in
- *	the range [0, num_syms - 1].  This parameter must be at least 2 and
- *	must not exceed (1 << NUM_SYMBOL_BITS).
- *
- * @max_codeword_len
- *	The maximum permissible codeword length.
- *
- * @freqs
- *	An array of length @num_syms that gives the frequency of each symbol.
- *	It is valid for some, none, or all of the frequencies to be 0.  The sum
- *	of frequencies must not exceed (1 << NUM_FREQ_BITS) - 1.
- *
- * @lens
- *	An array of @num_syms entries in which this function will return the
- *	length, in bits, of the codeword assigned to each symbol.  Symbols with
- *	0 frequency will not have codewords per se, but their entries in this
- *	array will be set to 0.  No lengths greater than @max_codeword_len will
- *	be assigned.
- *
- * @codewords
- *	An array of @num_syms entries in which this function will return the
- *	codeword for each symbol, right-justified and padded on the left with
- *	zeroes.  Codewords for symbols with 0 frequency will be undefined.
- *
- * ---------------------------------------------------------------------
- *
- * This function builds a length-limited canonical Huffman code.
- *
- * A length-limited Huffman code contains no codewords longer than some
- * specified length, and has exactly (with some algorithms) or approximately
- * (with the algorithm used here) the minimum weighted path length from the
- * root, given this constraint.
- *
- * A canonical Huffman code satisfies the properties that a longer codeword
- * never lexicographically precedes a shorter codeword, and the lexicographic
- * ordering of codewords of the same length is the same as the lexicographic
- * ordering of the corresponding symbols.  A canonical Huffman code, or more
- * generally a canonical prefix code, can be reconstructed from only a list
- * containing the codeword length of each symbol.
- *
- * The classic algorithm to generate a Huffman code creates a node for each
- * symbol, then inserts these nodes into a min-heap keyed by symbol frequency.
- * Then, repeatedly, the two lowest-frequency nodes are removed from the
- * min-heap and added as the children of a new node having frequency equal to
- * the sum of its two children, which is then inserted into the min-heap.  When
- * only a single node remains in the min-heap, it is the root of the Huffman
- * tree.  The codeword for each symbol is determined by the path needed to reach
- * the corresponding node from the root.  Descending to the left child appends a
- * 0 bit, whereas descending to the right child appends a 1 bit.
- *
- * The classic algorithm is relatively easy to understand, but it is subject to
- * a number of inefficiencies.  In practice, it is fastest to first sort the
- * symbols by frequency.  (This itself can be subject to an optimization based
- * on the fact that most frequencies tend to be low.)  At the same time, we sort
- * secondarily by symbol value, which aids the process of generating a canonical
- * code.  Then, during tree construction, no heap is necessary because both the
- * leaf nodes and the unparented non-leaf nodes can be easily maintained in
- * sorted order.  Consequently, there can never be more than two possibilities
- * for the next-lowest-frequency node.
- *
- * In addition, because we're generating a canonical code, we actually don't
- * need the leaf nodes of the tree at all, only the non-leaf nodes.  This is
- * because for canonical code generation we don't need to know where the symbols
- * are in the tree.  Rather, we only need to know how many leaf nodes have each
- * depth (codeword length).  And this information can, in fact, be quickly
- * generated from the tree of non-leaves only.
- *
- * Furthermore, we can build this stripped-down Huffman tree directly in the
- * array in which the codewords are to be generated, provided that these array
- * slots are large enough to hold a symbol and frequency value.
- *
- * Still furthermore, we don't even need to maintain explicit child pointers.
- * We only need the parent pointers, and even those can be overwritten in-place
- * with depth information as part of the process of extracting codeword lengths
- * from the tree.  So in summary, we do NOT need a big structure like:
- *
- *	struct huffman_tree_node {
- *		unsigned int symbol;
- *		unsigned int frequency;
- *		unsigned int depth;
- *		struct huffman_tree_node *left_child;
- *		struct huffman_tree_node *right_child;
- *	};
- *
- *
- * ... which often gets used in "naive" implementations of Huffman code
- * generation.
- *
- * Many of these optimizations are based on the implementation in 7-Zip (source
- * file: C/HuffEnc.c), which was placed in the public domain by Igor Pavlov.
- */
-static void
-deflate_make_huffman_code(unsigned num_syms, unsigned max_codeword_len,
-			  const u32 freqs[], u8 lens[], u32 codewords[])
-{
-	u32 *A = codewords;
-	unsigned num_used_syms;
-
-	STATIC_ASSERT(DEFLATE_MAX_NUM_SYMS <= 1 << NUM_SYMBOL_BITS);
-	STATIC_ASSERT(MAX_BLOCK_LENGTH <= ((u32)1 << NUM_FREQ_BITS) - 1);
-
-	/*
-	 * We begin by sorting the symbols primarily by frequency and
-	 * secondarily by symbol value.  As an optimization, the array used for
-	 * this purpose ('A') shares storage with the space in which we will
-	 * eventually return the codewords.
-	 */
-	num_used_syms = sort_symbols(num_syms, freqs, lens, A);
-	/*
-	 * 'num_used_syms' is the number of symbols with nonzero frequency.
-	 * This may be less than @num_syms.  'num_used_syms' is also the number
-	 * of entries in 'A' that are valid.  Each entry consists of a distinct
-	 * symbol and a nonzero frequency packed into a 32-bit integer.
-	 */
-
-	/*
-	 * A complete Huffman code must contain at least 2 codewords.  Yet, it's
-	 * possible that fewer than 2 symbols were used.  When this happens,
-	 * it's usually for the offset code (0-1 symbols used).  But it's also
-	 * theoretically possible for the litlen and pre codes (1 symbol used).
-	 *
-	 * The DEFLATE RFC explicitly allows the offset code to contain just 1
-	 * codeword, or even be completely empty.  But it's silent about the
-	 * other codes.  It also doesn't say whether, in the 1-codeword case,
-	 * the codeword (which it says must be 1 bit) is '0' or '1'.
-	 *
-	 * In any case, some DEFLATE decompressors reject these cases.  zlib
-	 * generally allows them, but it does reject precodes that have just 1
-	 * codeword.  More problematically, zlib v1.2.1 and earlier rejected
-	 * empty offset codes, and this behavior can also be seen in Windows
-	 * Explorer's ZIP unpacker (supposedly even still in Windows 11).
-	 *
-	 * Other DEFLATE compressors, including zlib, always send at least 2
-	 * codewords in order to make a complete Huffman code.  Therefore, this
-	 * is a case where practice does not entirely match the specification.
-	 * We follow practice by generating 2 codewords of length 1: codeword
-	 * '0' for symbol 0, and codeword '1' for another symbol -- the used
-	 * symbol if it exists and is not symbol 0, otherwise symbol 1.  This
-	 * does worsen the compression ratio by having to send an unnecessary
-	 * offset codeword length.  But this only affects rare cases such as
-	 * blocks containing all literals, and it only makes a tiny difference.
-	 */
-	if (unlikely(num_used_syms < 2)) {
-		unsigned sym = num_used_syms ? (A[0] & SYMBOL_MASK) : 0;
-		unsigned nonzero_idx = sym ? sym : 1;
-
-		codewords[0] = 0;
-		lens[0] = 1;
-		codewords[nonzero_idx] = 1;
-		lens[nonzero_idx] = 1;
-		return;
-	}
-
-	/*
-	 * Build a stripped-down version of the Huffman tree, sharing the array
-	 * 'A' with the symbol values.  Then extract length counts from the tree
-	 * and use them to generate the final codewords.
-	 */
-
-	build_tree(A, num_used_syms);
-
-	{
-		unsigned len_counts[DEFLATE_MAX_CODEWORD_LEN + 1];
-
-		compute_length_counts(A, num_used_syms - 2,
-				      len_counts, max_codeword_len);
-
-		gen_codewords(A, lens, len_counts, max_codeword_len, num_syms);
-	}
-}
-
-/*
- * Clear the Huffman symbol frequency counters.  This must be called when
- * starting a new DEFLATE block.
- */
-static void
-deflate_reset_symbol_frequencies(struct libdeflate_compressor *c)
-{
-	memset(&c->freqs, 0, sizeof(c->freqs));
-}
-
-/*
- * Build the literal/length and offset Huffman codes for a DEFLATE block.
- *
- * This takes as input the frequency tables for each alphabet and produces as
- * output a set of tables that map symbols to codewords and codeword lengths.
- */
-static void
-deflate_make_huffman_codes(const struct deflate_freqs *freqs,
-			   struct deflate_codes *codes)
-{
-	deflate_make_huffman_code(DEFLATE_NUM_LITLEN_SYMS,
-				  MAX_LITLEN_CODEWORD_LEN,
-				  freqs->litlen,
-				  codes->lens.litlen,
-				  codes->codewords.litlen);
-
-	deflate_make_huffman_code(DEFLATE_NUM_OFFSET_SYMS,
-				  MAX_OFFSET_CODEWORD_LEN,
-				  freqs->offset,
-				  codes->lens.offset,
-				  codes->codewords.offset);
-}
-
-/* Initialize c->static_codes. */
-static void
-deflate_init_static_codes(struct libdeflate_compressor *c)
-{
-	unsigned i;
-
-	for (i = 0; i < 144; i++)
-		c->freqs.litlen[i] = 1 << (9 - 8);
-	for (; i < 256; i++)
-		c->freqs.litlen[i] = 1 << (9 - 9);
-	for (; i < 280; i++)
-		c->freqs.litlen[i] = 1 << (9 - 7);
-	for (; i < 288; i++)
-		c->freqs.litlen[i] = 1 << (9 - 8);
-
-	for (i = 0; i < 32; i++)
-		c->freqs.offset[i] = 1 << (5 - 5);
-
-	deflate_make_huffman_codes(&c->freqs, &c->static_codes);
-}
-
-/* Return the offset slot for the given match offset, using the small map. */
-static forceinline unsigned
-deflate_get_offset_slot(u32 offset)
-{
-	/*
-	 * 1 <= offset <= 32768 here.  For 1 <= offset <= 256,
-	 * deflate_offset_slot[offset - 1] gives the slot.
-	 *
-	 * For 257 <= offset <= 32768, we take advantage of the fact that 257 is
-	 * the beginning of slot 16, and each slot [16..30) is exactly 1 << 7 ==
-	 * 128 times larger than each slot [2..16) (since the number of extra
-	 * bits increases by 1 every 2 slots).  Thus, the slot is:
-	 *
-	 *	deflate_offset_slot[2 + ((offset - 257) >> 7)] + (16 - 2)
-	 *   == deflate_offset_slot[((offset - 1) >> 7)] + 14
-	 *
-	 * Define 'n = (offset <= 256) ? 0 : 7'.  Then any offset is handled by:
-	 *
-	 *      deflate_offset_slot[(offset - 1) >> n] + (n << 1)
-	 *
-	 * For better performance, replace 'n = (offset <= 256) ? 0 : 7' with
-	 * the equivalent (for offset <= 536871168) 'n = (256 - offset) >> 29'.
-	 */
-	unsigned n = (256 - offset) >> 29;
-
-	ASSERT(offset >= 1 && offset <= 32768);
-
-	return deflate_offset_slot[(offset - 1) >> n] + (n << 1);
-}
-
-static unsigned
-deflate_compute_precode_items(const u8 lens[], const unsigned num_lens,
-			      u32 precode_freqs[], unsigned precode_items[])
-{
-	unsigned *itemptr;
-	unsigned run_start;
-	unsigned run_end;
-	unsigned extra_bits;
-	u8 len;
-
-	memset(precode_freqs, 0,
-	       DEFLATE_NUM_PRECODE_SYMS * sizeof(precode_freqs[0]));
-
-	itemptr = precode_items;
-	run_start = 0;
-	do {
-		/* Find the next run of codeword lengths. */
-
-		/* len = the length being repeated */
-		len = lens[run_start];
-
-		/* Extend the run. */
-		run_end = run_start;
-		do {
-			run_end++;
-		} while (run_end != num_lens && len == lens[run_end]);
-
-		if (len == 0) {
-			/* Run of zeroes. */
-
-			/* Symbol 18: RLE 11 to 138 zeroes at a time. */
-			while ((run_end - run_start) >= 11) {
-				extra_bits = MIN((run_end - run_start) - 11,
-						 0x7F);
-				precode_freqs[18]++;
-				*itemptr++ = 18 | (extra_bits << 5);
-				run_start += 11 + extra_bits;
-			}
-
-			/* Symbol 17: RLE 3 to 10 zeroes at a time. */
-			if ((run_end - run_start) >= 3) {
-				extra_bits = MIN((run_end - run_start) - 3,
-						 0x7);
-				precode_freqs[17]++;
-				*itemptr++ = 17 | (extra_bits << 5);
-				run_start += 3 + extra_bits;
-			}
-		} else {
-
-			/* A run of nonzero lengths. */
-
-			/* Symbol 16: RLE 3 to 6 of the previous length. */
-			if ((run_end - run_start) >= 4) {
-				precode_freqs[len]++;
-				*itemptr++ = len;
-				run_start++;
-				do {
-					extra_bits = MIN((run_end - run_start) -
-							 3, 0x3);
-					precode_freqs[16]++;
-					*itemptr++ = 16 | (extra_bits << 5);
-					run_start += 3 + extra_bits;
-				} while ((run_end - run_start) >= 3);
-			}
-		}
-
-		/* Output any remaining lengths without RLE. */
-		while (run_start != run_end) {
-			precode_freqs[len]++;
-			*itemptr++ = len;
-			run_start++;
-		}
-	} while (run_start != num_lens);
-
-	return itemptr - precode_items;
-}
-
-/*
- * Huffman codeword lengths for dynamic Huffman blocks are compressed using a
- * separate Huffman code, the "precode", which contains a symbol for each
- * possible codeword length in the larger code as well as several special
- * symbols to represent repeated codeword lengths (a form of run-length
- * encoding).  The precode is itself constructed in canonical form, and its
- * codeword lengths are represented literally in 19 3-bit fields that
- * immediately precede the compressed codeword lengths of the larger code.
- */
-
-/* Precompute the information needed to output dynamic Huffman codes. */
-static void
-deflate_precompute_huffman_header(struct libdeflate_compressor *c)
-{
-	/* Compute how many litlen and offset symbols are needed. */
-
-	for (c->o.precode.num_litlen_syms = DEFLATE_NUM_LITLEN_SYMS;
-	     c->o.precode.num_litlen_syms > 257;
-	     c->o.precode.num_litlen_syms--)
-		if (c->codes.lens.litlen[c->o.precode.num_litlen_syms - 1] != 0)
-			break;
-
-	for (c->o.precode.num_offset_syms = DEFLATE_NUM_OFFSET_SYMS;
-	     c->o.precode.num_offset_syms > 1;
-	     c->o.precode.num_offset_syms--)
-		if (c->codes.lens.offset[c->o.precode.num_offset_syms - 1] != 0)
-			break;
-
-	/*
-	 * If we're not using the full set of literal/length codeword lengths,
-	 * then temporarily move the offset codeword lengths over so that the
-	 * literal/length and offset codeword lengths are contiguous.
-	 */
-	STATIC_ASSERT(offsetof(struct deflate_lens, offset) ==
-		      DEFLATE_NUM_LITLEN_SYMS);
-	if (c->o.precode.num_litlen_syms != DEFLATE_NUM_LITLEN_SYMS) {
-		memmove((u8 *)&c->codes.lens + c->o.precode.num_litlen_syms,
-			(u8 *)&c->codes.lens + DEFLATE_NUM_LITLEN_SYMS,
-			c->o.precode.num_offset_syms);
-	}
-
-	/*
-	 * Compute the "items" (RLE / literal tokens and extra bits) with which
-	 * the codeword lengths in the larger code will be output.
-	 */
-	c->o.precode.num_items =
-		deflate_compute_precode_items((u8 *)&c->codes.lens,
-					      c->o.precode.num_litlen_syms +
-					      c->o.precode.num_offset_syms,
-					      c->o.precode.freqs,
-					      c->o.precode.items);
-
-	/* Build the precode. */
-	deflate_make_huffman_code(DEFLATE_NUM_PRECODE_SYMS,
-				  MAX_PRE_CODEWORD_LEN,
-				  c->o.precode.freqs, c->o.precode.lens,
-				  c->o.precode.codewords);
-
-	/* Count how many precode lengths we actually need to output. */
-	for (c->o.precode.num_explicit_lens = DEFLATE_NUM_PRECODE_SYMS;
-	     c->o.precode.num_explicit_lens > 4;
-	     c->o.precode.num_explicit_lens--)
-		if (c->o.precode.lens[deflate_precode_lens_permutation[
-				c->o.precode.num_explicit_lens - 1]] != 0)
-			break;
-
-	/* Restore the offset codeword lengths if needed. */
-	if (c->o.precode.num_litlen_syms != DEFLATE_NUM_LITLEN_SYMS) {
-		memmove((u8 *)&c->codes.lens + DEFLATE_NUM_LITLEN_SYMS,
-			(u8 *)&c->codes.lens + c->o.precode.num_litlen_syms,
-			c->o.precode.num_offset_syms);
-	}
-}
-
-/*
- * To make it faster to output matches, compute the "full" match length
- * codewords, i.e. the concatenation of the litlen codeword and the extra bits
- * for each possible match length.
- */
-static void
-deflate_compute_full_len_codewords(struct libdeflate_compressor *c,
-				   const struct deflate_codes *codes)
-{
-	u32 len;
-
-	STATIC_ASSERT(MAX_LITLEN_CODEWORD_LEN +
-		      DEFLATE_MAX_EXTRA_LENGTH_BITS <= 32);
-
-	for (len = DEFLATE_MIN_MATCH_LEN; len <= DEFLATE_MAX_MATCH_LEN; len++) {
-		unsigned slot = deflate_length_slot[len];
-		unsigned litlen_sym = DEFLATE_FIRST_LEN_SYM + slot;
-		u32 extra_bits = len - deflate_length_slot_base[slot];
-
-		c->o.length.codewords[len] =
-			codes->codewords.litlen[litlen_sym] |
-			(extra_bits << codes->lens.litlen[litlen_sym]);
-		c->o.length.lens[len] = codes->lens.litlen[litlen_sym] +
-					deflate_extra_length_bits[slot];
-	}
-}
-
-/* Write a match to the output buffer. */
-#define WRITE_MATCH(c_, codes_, length_, offset_, offset_slot_)		\
-do {									\
-	const struct libdeflate_compressor *c__ = (c_);			\
-	const struct deflate_codes *codes__ = (codes_);			\
-	u32 length__ = (length_);					\
-	u32 offset__ = (offset_);					\
-	unsigned offset_slot__ = (offset_slot_);			\
-									\
-	/* Litlen symbol and extra length bits */			\
-	STATIC_ASSERT(CAN_BUFFER(MAX_LITLEN_CODEWORD_LEN +		\
-				 DEFLATE_MAX_EXTRA_LENGTH_BITS));	\
-	ADD_BITS(c__->o.length.codewords[length__],			\
-		 c__->o.length.lens[length__]);				\
-									\
-	if (!CAN_BUFFER(MAX_LITLEN_CODEWORD_LEN +			\
-			DEFLATE_MAX_EXTRA_LENGTH_BITS +			\
-			MAX_OFFSET_CODEWORD_LEN +			\
-			DEFLATE_MAX_EXTRA_OFFSET_BITS))			\
-		FLUSH_BITS();						\
-									\
-	/* Offset symbol */						\
-	ADD_BITS(codes__->codewords.offset[offset_slot__],		\
-		 codes__->lens.offset[offset_slot__]);			\
-									\
-	if (!CAN_BUFFER(MAX_OFFSET_CODEWORD_LEN +			\
-			DEFLATE_MAX_EXTRA_OFFSET_BITS))			\
-		FLUSH_BITS();						\
-									\
-	/* Extra offset bits */						\
-	ADD_BITS(offset__ - deflate_offset_slot_base[offset_slot__],	\
-		 deflate_extra_offset_bits[offset_slot__]);		\
-									\
-	FLUSH_BITS();							\
-} while (0)
-
-/*
- * Choose the best type of block to use (dynamic Huffman, static Huffman, or
- * uncompressed), then output it.
- *
- * The uncompressed data of the block is @block_begin[0..@block_length-1].  The
- * sequence of literals and matches that will be used to compress the block (if
- * a compressed block is chosen) is given by @sequences if it's non-NULL, or
- * else @c->p.n.optimum_nodes.  @c->freqs and @c->codes must be already set
- * according to the literals, matches, and end-of-block symbol.
- */
-static void
-deflate_flush_block(struct libdeflate_compressor *c,
-		    struct deflate_output_bitstream *os,
-		    const u8 *block_begin, u32 block_length,
-		    const struct deflate_sequence *sequences,
-		    bool is_final_block)
-{
-	/*
-	 * It is hard to get compilers to understand that writes to 'os->next'
-	 * don't alias 'os'.  That hurts performance significantly, as
-	 * everything in 'os' would keep getting re-loaded.  ('restrict'
-	 * *should* do the trick, but it's unreliable.)  Therefore, we keep all
-	 * the output bitstream state in local variables, and output bits using
-	 * macros.  This is similar to what the decompressor does.
-	 */
-	const u8 *in_next = block_begin;
-	const u8 * const in_end = block_begin + block_length;
-	bitbuf_t bitbuf = os->bitbuf;
-	unsigned bitcount = os->bitcount;
-	u8 *out_next = os->next;
-	u8 * const out_fast_end =
-		os->end - MIN(WORDBYTES - 1, os->end - out_next);
-	/*
-	 * The cost for each block type, in bits.  Start with the cost of the
-	 * block header which is 3 bits.
-	 */
-	u32 dynamic_cost = 3;
-	u32 static_cost = 3;
-	u32 uncompressed_cost = 3;
-	u32 best_cost;
-	struct deflate_codes *codes;
-	unsigned sym;
-
-	ASSERT(block_length >= MIN_BLOCK_LENGTH ||
-	       (is_final_block && block_length > 0));
-	ASSERT(block_length <= MAX_BLOCK_LENGTH);
-	ASSERT(bitcount <= 7);
-	ASSERT((bitbuf & ~(((bitbuf_t)1 << bitcount) - 1)) == 0);
-	ASSERT(out_next <= os->end);
-	ASSERT(!os->overflow);
-
-	/* Precompute the precode items and build the precode. */
-	deflate_precompute_huffman_header(c);
-
-	/* Account for the cost of encoding dynamic Huffman codes. */
-	dynamic_cost += 5 + 5 + 4 + (3 * c->o.precode.num_explicit_lens);
-	for (sym = 0; sym < DEFLATE_NUM_PRECODE_SYMS; sym++) {
-		u32 extra = deflate_extra_precode_bits[sym];
-
-		dynamic_cost += c->o.precode.freqs[sym] *
-				(extra + c->o.precode.lens[sym]);
-	}
-
-	/* Account for the cost of encoding literals. */
-	for (sym = 0; sym < 144; sym++) {
-		dynamic_cost += c->freqs.litlen[sym] *
-				c->codes.lens.litlen[sym];
-		static_cost += c->freqs.litlen[sym] * 8;
-	}
-	for (; sym < 256; sym++) {
-		dynamic_cost += c->freqs.litlen[sym] *
-				c->codes.lens.litlen[sym];
-		static_cost += c->freqs.litlen[sym] * 9;
-	}
-
-	/* Account for the cost of encoding the end-of-block symbol. */
-	dynamic_cost += c->codes.lens.litlen[DEFLATE_END_OF_BLOCK];
-	static_cost += 7;
-
-	/* Account for the cost of encoding lengths. */
-	for (sym = DEFLATE_FIRST_LEN_SYM;
-	     sym < DEFLATE_FIRST_LEN_SYM + ARRAY_LEN(deflate_extra_length_bits);
-	     sym++) {
-		u32 extra = deflate_extra_length_bits[
-					sym - DEFLATE_FIRST_LEN_SYM];
-
-		dynamic_cost += c->freqs.litlen[sym] *
-				(extra + c->codes.lens.litlen[sym]);
-		static_cost += c->freqs.litlen[sym] *
-				(extra + c->static_codes.lens.litlen[sym]);
-	}
-
-	/* Account for the cost of encoding offsets. */
-	for (sym = 0; sym < ARRAY_LEN(deflate_extra_offset_bits); sym++) {
-		u32 extra = deflate_extra_offset_bits[sym];
-
-		dynamic_cost += c->freqs.offset[sym] *
-				(extra + c->codes.lens.offset[sym]);
-		static_cost += c->freqs.offset[sym] * (extra + 5);
-	}
-
-	/* Compute the cost of using uncompressed blocks. */
-	uncompressed_cost += (-(bitcount + 3) & 7) + 32 +
-			     (40 * (DIV_ROUND_UP(block_length,
-						 UINT16_MAX) - 1)) +
-			     (8 * block_length);
-
-	/*
-	 * Choose and output the cheapest type of block.  If there is a tie,
-	 * prefer uncompressed, then static, then dynamic.
-	 */
-
-	best_cost = MIN(dynamic_cost, MIN(static_cost, uncompressed_cost));
-
-	/* If the block isn't going to fit, then stop early. */
-	if (DIV_ROUND_UP(bitcount + best_cost, 8) > os->end - out_next) {
-		os->overflow = true;
-		return;
-	}
-	/*
-	 * Else, now we know that the block fits, so no further bounds checks on
-	 * the output buffer are required until the next block.
-	 */
-
-	if (best_cost == uncompressed_cost) {
-		/*
-		 * Uncompressed block(s).  DEFLATE limits the length of
-		 * uncompressed blocks to UINT16_MAX bytes, so if the length of
-		 * the "block" we're flushing is over UINT16_MAX, we actually
-		 * output multiple blocks.
-		 */
-		do {
-			u8 bfinal = 0;
-			size_t len = UINT16_MAX;
-
-			if (in_end - in_next <= UINT16_MAX) {
-				bfinal = is_final_block;
-				len = in_end - in_next;
-			}
-			/* It was already checked that there is enough space. */
-			ASSERT(os->end - out_next >=
-			       DIV_ROUND_UP(bitcount + 3, 8) + 4 + len);
-			/*
-			 * Output BFINAL (1 bit) and BTYPE (2 bits), then align
-			 * to a byte boundary.
-			 */
-			STATIC_ASSERT(DEFLATE_BLOCKTYPE_UNCOMPRESSED == 0);
-			*out_next++ = (bfinal << bitcount) | bitbuf;
-			if (bitcount > 5)
-				*out_next++ = 0;
-			bitbuf = 0;
-			bitcount = 0;
-			/* Output LEN and NLEN, then the data itself. */
-			put_unaligned_le16(len, out_next);
-			out_next += 2;
-			put_unaligned_le16(~len, out_next);
-			out_next += 2;
-			memcpy(out_next, in_next, len);
-			out_next += len;
-			in_next += len;
-		} while (in_next != in_end);
-		/* Done outputting uncompressed block(s) */
-		goto out;
-	}
-
-	if (best_cost == static_cost) {
-		/* Static Huffman block */
-		codes = &c->static_codes;
-		ADD_BITS(is_final_block, 1);
-		ADD_BITS(DEFLATE_BLOCKTYPE_STATIC_HUFFMAN, 2);
-		FLUSH_BITS();
-	} else {
-		const unsigned num_explicit_lens = c->o.precode.num_explicit_lens;
-		const unsigned num_precode_items = c->o.precode.num_items;
-		unsigned precode_sym, precode_item;
-		unsigned i;
-
-		/* Dynamic Huffman block */
-
-		codes = &c->codes;
-		STATIC_ASSERT(CAN_BUFFER(1 + 2 + 5 + 5 + 4 + 3));
-		ADD_BITS(is_final_block, 1);
-		ADD_BITS(DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN, 2);
-		ADD_BITS(c->o.precode.num_litlen_syms - 257, 5);
-		ADD_BITS(c->o.precode.num_offset_syms - 1, 5);
-		ADD_BITS(num_explicit_lens - 4, 4);
-
-		/* Output the lengths of the codewords in the precode. */
-		if (CAN_BUFFER(3 * (DEFLATE_NUM_PRECODE_SYMS - 1))) {
-			/*
-			 * A 64-bit bitbuffer is just one bit too small to hold
-			 * the maximum number of precode lens, so to minimize
-			 * flushes we merge one len with the previous fields.
-			 */
-			precode_sym = deflate_precode_lens_permutation[0];
-			ADD_BITS(c->o.precode.lens[precode_sym], 3);
-			FLUSH_BITS();
-			i = 1; /* num_explicit_lens >= 4 */
-			do {
-				precode_sym =
-					deflate_precode_lens_permutation[i];
-				ADD_BITS(c->o.precode.lens[precode_sym], 3);
-			} while (++i < num_explicit_lens);
-			FLUSH_BITS();
-		} else {
-			FLUSH_BITS();
-			i = 0;
-			do {
-				precode_sym =
-					deflate_precode_lens_permutation[i];
-				ADD_BITS(c->o.precode.lens[precode_sym], 3);
-				FLUSH_BITS();
-			} while (++i < num_explicit_lens);
-		}
-
-		/*
-		 * Output the lengths of the codewords in the litlen and offset
-		 * codes, encoded by the precode.
-		 */
-		i = 0;
-		do {
-			precode_item = c->o.precode.items[i];
-			precode_sym = precode_item & 0x1F;
-			STATIC_ASSERT(CAN_BUFFER(MAX_PRE_CODEWORD_LEN + 7));
-			ADD_BITS(c->o.precode.codewords[precode_sym],
-				 c->o.precode.lens[precode_sym]);
-			ADD_BITS(precode_item >> 5,
-				 deflate_extra_precode_bits[precode_sym]);
-			FLUSH_BITS();
-		} while (++i < num_precode_items);
-	}
-
-	/* Output the literals and matches for a dynamic or static block. */
-	ASSERT(bitcount <= 7);
-	deflate_compute_full_len_codewords(c, codes);
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-	if (sequences == NULL) {
-		/* Output the literals and matches from the minimum-cost path */
-		struct deflate_optimum_node *cur_node =
-			&c->p.n.optimum_nodes[0];
-		struct deflate_optimum_node * const end_node =
-			&c->p.n.optimum_nodes[block_length];
-		do {
-			u32 length = cur_node->item & OPTIMUM_LEN_MASK;
-			u32 offset = cur_node->item >> OPTIMUM_OFFSET_SHIFT;
-
-			if (length == 1) {
-				/* Literal */
-				ADD_BITS(codes->codewords.litlen[offset],
-					 codes->lens.litlen[offset]);
-				FLUSH_BITS();
-			} else {
-				/* Match */
-				WRITE_MATCH(c, codes, length, offset,
-					    c->p.n.offset_slot_full[offset]);
-			}
-			cur_node += length;
-		} while (cur_node != end_node);
-	} else
-#endif /* SUPPORT_NEAR_OPTIMAL_PARSING */
-	{
-		/* Output the literals and matches from the sequences list. */
-		const struct deflate_sequence *seq;
-
-		for (seq = sequences; ; seq++) {
-			u32 litrunlen = seq->litrunlen_and_length &
-					SEQ_LITRUNLEN_MASK;
-			u32 length = seq->litrunlen_and_length >>
-				     SEQ_LENGTH_SHIFT;
-			unsigned lit;
-
-			/* Output a run of literals. */
-			if (CAN_BUFFER(4 * MAX_LITLEN_CODEWORD_LEN)) {
-				for (; litrunlen >= 4; litrunlen -= 4) {
-					lit = *in_next++;
-					ADD_BITS(codes->codewords.litlen[lit],
-						 codes->lens.litlen[lit]);
-					lit = *in_next++;
-					ADD_BITS(codes->codewords.litlen[lit],
-						 codes->lens.litlen[lit]);
-					lit = *in_next++;
-					ADD_BITS(codes->codewords.litlen[lit],
-						 codes->lens.litlen[lit]);
-					lit = *in_next++;
-					ADD_BITS(codes->codewords.litlen[lit],
-						 codes->lens.litlen[lit]);
-					FLUSH_BITS();
-				}
-				if (litrunlen-- != 0) {
-					lit = *in_next++;
-					ADD_BITS(codes->codewords.litlen[lit],
-						 codes->lens.litlen[lit]);
-					if (litrunlen-- != 0) {
-						lit = *in_next++;
-						ADD_BITS(codes->codewords.litlen[lit],
-							 codes->lens.litlen[lit]);
-						if (litrunlen-- != 0) {
-							lit = *in_next++;
-							ADD_BITS(codes->codewords.litlen[lit],
-								 codes->lens.litlen[lit]);
-						}
-					}
-					FLUSH_BITS();
-				}
-			} else {
-				while (litrunlen--) {
-					lit = *in_next++;
-					ADD_BITS(codes->codewords.litlen[lit],
-						 codes->lens.litlen[lit]);
-					FLUSH_BITS();
-				}
-			}
-
-			if (length == 0) { /* Last sequence? */
-				ASSERT(in_next == in_end);
-				break;
-			}
-
-			/* Output a match. */
-			WRITE_MATCH(c, codes, length, seq->offset,
-				    seq->offset_slot);
-			in_next += length;
-		}
-	}
-
-	/* Output the end-of-block symbol. */
-	ASSERT(bitcount <= 7);
-	ADD_BITS(codes->codewords.litlen[DEFLATE_END_OF_BLOCK],
-		 codes->lens.litlen[DEFLATE_END_OF_BLOCK]);
-	FLUSH_BITS();
-out:
-	ASSERT(bitcount <= 7);
-	/*
-	 * Assert that the block cost was computed correctly.  This is relied on
-	 * above for the bounds check on the output buffer.  Also,
-	 * libdeflate_deflate_compress_bound() relies on this via the assumption
-	 * that uncompressed blocks will always be used when cheapest.
-	 */
-	ASSERT(8 * (out_next - os->next) + bitcount - os->bitcount == best_cost);
-	os->bitbuf = bitbuf;
-	os->bitcount = bitcount;
-	os->next = out_next;
-}
-
-static void
-deflate_finish_block(struct libdeflate_compressor *c,
-		     struct deflate_output_bitstream *os,
-		     const u8 *block_begin, u32 block_length,
-		     const struct deflate_sequence *sequences,
-		     bool is_final_block)
-{
-	c->freqs.litlen[DEFLATE_END_OF_BLOCK]++;
-	deflate_make_huffman_codes(&c->freqs, &c->codes);
-	deflate_flush_block(c, os, block_begin, block_length, sequences,
-			    is_final_block);
-}
-
-/******************************************************************************/
-
-/*
- * Block splitting algorithm.  The problem is to decide when it is worthwhile to
- * start a new block with new Huffman codes.  There is a theoretically optimal
- * solution: recursively consider every possible block split, considering the
- * exact cost of each block, and choose the minimum cost approach.  But this is
- * far too slow.  Instead, as an approximation, we can count symbols and after
- * every N symbols, compare the expected distribution of symbols based on the
- * previous data with the actual distribution.  If they differ "by enough", then
- * start a new block.
- *
- * As an optimization and heuristic, we don't distinguish between every symbol
- * but rather we combine many symbols into a single "observation type".  For
- * literals we only look at the high bits and low bits, and for matches we only
- * look at whether the match is long or not.  The assumption is that for typical
- * "real" data, places that are good block boundaries will tend to be noticeable
- * based only on changes in these aggregate probabilities, without looking for
- * subtle differences in individual symbols.  For example, a change from ASCII
- * bytes to non-ASCII bytes, or from few matches (generally less compressible)
- * to many matches (generally more compressible), would be easily noticed based
- * on the aggregates.
- *
- * For determining whether the probability distributions are "different enough"
- * to start a new block, the simple heuristic of splitting when the sum of
- * absolute differences exceeds a constant seems to be good enough.  We also add
- * a number proportional to the block length so that the algorithm is more
- * likely to end long blocks than short blocks.  This reflects the general
- * expectation that it will become increasingly beneficial to start a new block
- * as the current block grows longer.
- *
- * Finally, for an approximation, it is not strictly necessary that the exact
- * symbols being used are considered.  With "near-optimal parsing", for example,
- * the actual symbols that will be used are unknown until after the block
- * boundary is chosen and the block has been optimized.  Since the final choices
- * cannot be used, we can use preliminary "greedy" choices instead.
- */
-
-/* Initialize the block split statistics when starting a new block. */
-static void
-init_block_split_stats(struct block_split_stats *stats)
-{
-	int i;
-
-	for (i = 0; i < NUM_OBSERVATION_TYPES; i++) {
-		stats->new_observations[i] = 0;
-		stats->observations[i] = 0;
-	}
-	stats->num_new_observations = 0;
-	stats->num_observations = 0;
-}
-
-/*
- * Literal observation.  Heuristic: use the top 2 bits and low 1 bits of the
- * literal, for 8 possible literal observation types.
- */
-static forceinline void
-observe_literal(struct block_split_stats *stats, u8 lit)
-{
-	stats->new_observations[((lit >> 5) & 0x6) | (lit & 1)]++;
-	stats->num_new_observations++;
-}
-
-/*
- * Match observation.  Heuristic: use one observation type for "short match" and
- * one observation type for "long match".
- */
-static forceinline void
-observe_match(struct block_split_stats *stats, u32 length)
-{
-	stats->new_observations[NUM_LITERAL_OBSERVATION_TYPES +
-				(length >= 9)]++;
-	stats->num_new_observations++;
-}
-
-static void
-merge_new_observations(struct block_split_stats *stats)
-{
-	int i;
-
-	for (i = 0; i < NUM_OBSERVATION_TYPES; i++) {
-		stats->observations[i] += stats->new_observations[i];
-		stats->new_observations[i] = 0;
-	}
-	stats->num_observations += stats->num_new_observations;
-	stats->num_new_observations = 0;
-}
-
-static bool
-do_end_block_check(struct block_split_stats *stats, u32 block_length)
-{
-	if (stats->num_observations > 0) {
-		/*
-		 * Compute the sum of absolute differences of probabilities.  To
-		 * avoid needing to use floating point arithmetic or do slow
-		 * divisions, we do all arithmetic with the probabilities
-		 * multiplied by num_observations * num_new_observations.  E.g.,
-		 * for the "old" observations the probabilities would be
-		 * (double)observations[i] / num_observations, but since we
-		 * multiply by both num_observations and num_new_observations we
-		 * really do observations[i] * num_new_observations.
-		 */
-		u32 total_delta = 0;
-		u32 num_items;
-		u32 cutoff;
-		int i;
-
-		for (i = 0; i < NUM_OBSERVATION_TYPES; i++) {
-			u32 expected = stats->observations[i] *
-				       stats->num_new_observations;
-			u32 actual = stats->new_observations[i] *
-				     stats->num_observations;
-			u32 delta = (actual > expected) ? actual - expected :
-							  expected - actual;
-
-			total_delta += delta;
-		}
-
-		num_items = stats->num_observations +
-			    stats->num_new_observations;
-		/*
-		 * Heuristic: the cutoff is when the sum of absolute differences
-		 * of probabilities becomes at least 200/512.  As above, the
-		 * probability is multiplied by both num_new_observations and
-		 * num_observations.  Be careful to avoid integer overflow.
-		 */
-		cutoff = stats->num_new_observations * 200 / 512 *
-			 stats->num_observations;
-		/*
-		 * Very short blocks have a lot of overhead for the Huffman
-		 * codes, so only use them if it clearly seems worthwhile.
-		 * (This is an additional penalty, which adds to the smaller
-		 * penalty below which scales more slowly.)
-		 */
-		if (block_length < 10000 && num_items < 8192)
-			cutoff += (u64)cutoff * (8192 - num_items) / 8192;
-
-		/* Ready to end the block? */
-		if (total_delta +
-		    (block_length / 4096) * stats->num_observations >= cutoff)
-			return true;
-	}
-	merge_new_observations(stats);
-	return false;
-}
-
-static forceinline bool
-ready_to_check_block(const struct block_split_stats *stats,
-		     const u8 *in_block_begin, const u8 *in_next,
-		     const u8 *in_end)
-{
-	return stats->num_new_observations >= NUM_OBSERVATIONS_PER_BLOCK_CHECK
-		&& in_next - in_block_begin >= MIN_BLOCK_LENGTH
-		&& in_end - in_next >= MIN_BLOCK_LENGTH;
-}
-
-static forceinline bool
-should_end_block(struct block_split_stats *stats,
-		 const u8 *in_block_begin, const u8 *in_next, const u8 *in_end)
-{
-	/* Ready to try to end the block (again)? */
-	if (!ready_to_check_block(stats, in_block_begin, in_next, in_end))
-		return false;
-
-	return do_end_block_check(stats, in_next - in_block_begin);
-}
-
-/******************************************************************************/
-
-static void
-deflate_begin_sequences(struct libdeflate_compressor *c,
-			struct deflate_sequence *first_seq)
-{
-	deflate_reset_symbol_frequencies(c);
-	first_seq->litrunlen_and_length = 0;
-}
-
-static forceinline void
-deflate_choose_literal(struct libdeflate_compressor *c, unsigned literal,
-		       bool gather_split_stats, struct deflate_sequence *seq)
-{
-	c->freqs.litlen[literal]++;
-
-	if (gather_split_stats)
-		observe_literal(&c->split_stats, literal);
-
-	STATIC_ASSERT(MAX_BLOCK_LENGTH <= SEQ_LITRUNLEN_MASK);
-	seq->litrunlen_and_length++;
-}
-
-static forceinline void
-deflate_choose_match(struct libdeflate_compressor *c,
-		     u32 length, u32 offset, bool gather_split_stats,
-		     struct deflate_sequence **seq_p)
-{
-	struct deflate_sequence *seq = *seq_p;
-	unsigned length_slot = deflate_length_slot[length];
-	unsigned offset_slot = deflate_get_offset_slot(offset);
-
-	c->freqs.litlen[DEFLATE_FIRST_LEN_SYM + length_slot]++;
-	c->freqs.offset[offset_slot]++;
-	if (gather_split_stats)
-		observe_match(&c->split_stats, length);
-
-	seq->litrunlen_and_length |= length << SEQ_LENGTH_SHIFT;
-	seq->offset = offset;
-	seq->offset_slot = offset_slot;
-
-	seq++;
-	seq->litrunlen_and_length = 0;
-	*seq_p = seq;
-}
-
-/*
- * Decrease the maximum and nice match lengths if we're approaching the end of
- * the input buffer.
- */
-static forceinline void
-adjust_max_and_nice_len(u32 *max_len, u32 *nice_len, size_t remaining)
-{
-	if (unlikely(remaining < DEFLATE_MAX_MATCH_LEN)) {
-		*max_len = remaining;
-		*nice_len = MIN(*nice_len, *max_len);
-	}
-}
-
-/*
- * Choose the minimum match length for the greedy and lazy parsers.
- *
- * By default the minimum match length is 3, which is the smallest length the
- * DEFLATE format allows.  However, with greedy and lazy parsing, some data
- * (e.g. DNA sequencing data) benefits greatly from a longer minimum length.
- * Typically, this is because literals are very cheap.  In general, the
- * near-optimal parser handles this case naturally, but the greedy and lazy
- * parsers need a heuristic to decide when to use short matches.
- *
- * The heuristic we use is to make the minimum match length depend on the number
- * of different literals that exist in the data.  If there are many different
- * literals, then literals will probably be expensive, so short matches will
- * probably be worthwhile.  Conversely, if not many literals are used, then
- * probably literals will be cheap and short matches won't be worthwhile.
- */
-static u32
-choose_min_match_len(u32 num_used_literals, u32 max_search_depth)
-{
-	/* map from num_used_literals to min_len */
-	static const u8 min_lens[] = {
-		9, 9, 9, 9, 9, 9, 8, 8, 7, 7, 6, 6, 6, 6, 6, 6,
-		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4,
-		4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-		4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-		/* The rest is implicitly 3. */
-	};
-	u32 min_len;
-
-	STATIC_ASSERT(DEFLATE_MIN_MATCH_LEN <= 3);
-	STATIC_ASSERT(ARRAY_LEN(min_lens) <= DEFLATE_NUM_LITERALS + 1);
-
-	if (num_used_literals >= ARRAY_LEN(min_lens))
-		return 3;
-	min_len = min_lens[num_used_literals];
-	/*
-	 * With a low max_search_depth, it may be too hard to find long matches.
-	 */
-	if (max_search_depth < 16) {
-		if (max_search_depth < 5)
-			min_len = MIN(min_len, 4);
-		else if (max_search_depth < 10)
-			min_len = MIN(min_len, 5);
-		else
-			min_len = MIN(min_len, 7);
-	}
-	return min_len;
-}
-
-static u32
-calculate_min_match_len(const u8 *data, size_t data_len, u32 max_search_depth)
-{
-	u8 used[256] = { 0 };
-	u32 num_used_literals = 0;
-	size_t i;
-
-	/*
-	 * For very short inputs, the static Huffman code has a good chance of
-	 * being best, in which case there is no reason to avoid short matches.
-	 */
-	if (data_len < 512)
-		return DEFLATE_MIN_MATCH_LEN;
-
-	/*
-	 * For an initial approximation, scan the first 4 KiB of data.  The
-	 * caller may use recalculate_min_match_len() to update min_len later.
-	 */
-	data_len = MIN(data_len, 4096);
-	for (i = 0; i < data_len; i++)
-		used[data[i]] = 1;
-	for (i = 0; i < 256; i++)
-		num_used_literals += used[i];
-	return choose_min_match_len(num_used_literals, max_search_depth);
-}
-
-/*
- * Recalculate the minimum match length for a block, now that we know the
- * distribution of literals that are actually being used (freqs->litlen).
- */
-static u32
-recalculate_min_match_len(const struct deflate_freqs *freqs,
-			  u32 max_search_depth)
-{
-	u32 literal_freq = 0;
-	u32 cutoff;
-	u32 num_used_literals = 0;
-	int i;
-
-	for (i = 0; i < DEFLATE_NUM_LITERALS; i++)
-		literal_freq += freqs->litlen[i];
-
-	cutoff = literal_freq >> 10; /* Ignore literals used very rarely. */
-
-	for (i = 0; i < DEFLATE_NUM_LITERALS; i++) {
-		if (freqs->litlen[i] > cutoff)
-			num_used_literals++;
-	}
-	return choose_min_match_len(num_used_literals, max_search_depth);
-}
-
-static forceinline const u8 *
-choose_max_block_end(const u8 *in_block_begin, const u8 *in_end,
-		     size_t soft_max_len)
-{
-	if (in_end - in_block_begin < soft_max_len + MIN_BLOCK_LENGTH)
-		return in_end;
-	return in_block_begin + soft_max_len;
-}
-
-/*
- * This is the level 0 "compressor".  It always outputs uncompressed blocks.
- */
-static size_t
-deflate_compress_none(const u8 *in, size_t in_nbytes,
-		      u8 *out, size_t out_nbytes_avail)
-{
-	const u8 *in_next = in;
-	const u8 * const in_end = in + in_nbytes;
-	u8 *out_next = out;
-	u8 * const out_end = out + out_nbytes_avail;
-
-	/*
-	 * If the input is zero-length, we still must output a block in order
-	 * for the output to be a valid DEFLATE stream.  Handle this case
-	 * specially to avoid potentially passing NULL to memcpy() below.
-	 */
-	if (unlikely(in_nbytes == 0)) {
-		if (out_nbytes_avail < 5)
-			return 0;
-		/* BFINAL and BTYPE */
-		*out_next++ = 1 | (DEFLATE_BLOCKTYPE_UNCOMPRESSED << 1);
-		/* LEN and NLEN */
-		put_unaligned_le32(0xFFFF0000, out_next);
-		return 5;
-	}
-
-	do {
-		u8 bfinal = 0;
-		size_t len = UINT16_MAX;
-
-		if (in_end - in_next <= UINT16_MAX) {
-			bfinal = 1;
-			len = in_end - in_next;
-		}
-		if (out_end - out_next < 5 + len)
-			return 0;
-		/*
-		 * Output BFINAL and BTYPE.  The stream is already byte-aligned
-		 * here, so this step always requires outputting exactly 1 byte.
-		 */
-		*out_next++ = bfinal | (DEFLATE_BLOCKTYPE_UNCOMPRESSED << 1);
-
-		/* Output LEN and NLEN, then the data itself. */
-		put_unaligned_le16(len, out_next);
-		out_next += 2;
-		put_unaligned_le16(~len, out_next);
-		out_next += 2;
-		memcpy(out_next, in_next, len);
-		out_next += len;
-		in_next += len;
-	} while (in_next != in_end);
-
-	return out_next - out;
-}
-
-/*
- * This is a faster variant of deflate_compress_greedy().  It uses the
- * ht_matchfinder rather than the hc_matchfinder.  It also skips the block
- * splitting algorithm and just uses fixed length blocks.  c->max_search_depth
- * has no effect with this algorithm, as it is hardcoded in ht_matchfinder.h.
- */
-static void
-deflate_compress_fastest(struct libdeflate_compressor * restrict c,
-			 const u8 *in, size_t in_nbytes,
-			 struct deflate_output_bitstream *os)
-{
-	const u8 *in_next = in;
-	const u8 *in_end = in_next + in_nbytes;
-	const u8 *in_cur_base = in_next;
-	u32 max_len = DEFLATE_MAX_MATCH_LEN;
-	u32 nice_len = MIN(c->nice_match_length, max_len);
-	u32 next_hash = 0;
-
-	ht_matchfinder_init(&c->p.f.ht_mf);
-
-	do {
-		/* Starting a new DEFLATE block */
-
-		const u8 * const in_block_begin = in_next;
-		const u8 * const in_max_block_end = choose_max_block_end(
-				in_next, in_end, FAST_SOFT_MAX_BLOCK_LENGTH);
-		struct deflate_sequence *seq = c->p.f.sequences;
-
-		deflate_begin_sequences(c, seq);
-
-		do {
-			u32 length;
-			u32 offset;
-			size_t remaining = in_end - in_next;
-
-			if (unlikely(remaining < DEFLATE_MAX_MATCH_LEN)) {
-				max_len = remaining;
-				if (max_len < HT_MATCHFINDER_REQUIRED_NBYTES) {
-					do {
-						deflate_choose_literal(c,
-							*in_next++, false, seq);
-					} while (--max_len);
-					break;
-				}
-				nice_len = MIN(nice_len, max_len);
-			}
-			length = ht_matchfinder_longest_match(&c->p.f.ht_mf,
-							      &in_cur_base,
-							      in_next,
-							      max_len,
-							      nice_len,
-							      &next_hash,
-							      &offset);
-			if (length) {
-				/* Match found */
-				deflate_choose_match(c, length, offset, false,
-						     &seq);
-				ht_matchfinder_skip_bytes(&c->p.f.ht_mf,
-							  &in_cur_base,
-							  in_next + 1,
-							  in_end,
-							  length - 1,
-							  &next_hash);
-				in_next += length;
-			} else {
-				/* No match found */
-				deflate_choose_literal(c, *in_next++, false,
-						       seq);
-			}
-
-			/* Check if it's time to output another block. */
-		} while (in_next < in_max_block_end &&
-			 seq < &c->p.f.sequences[FAST_SEQ_STORE_LENGTH]);
-
-		deflate_finish_block(c, os, in_block_begin,
-				     in_next - in_block_begin,
-				     c->p.f.sequences, in_next == in_end);
-	} while (in_next != in_end && !os->overflow);
-}
-
-/*
- * This is the "greedy" DEFLATE compressor. It always chooses the longest match.
- */
-static void
-deflate_compress_greedy(struct libdeflate_compressor * restrict c,
-			const u8 *in, size_t in_nbytes,
-			struct deflate_output_bitstream *os)
-{
-	const u8 *in_next = in;
-	const u8 *in_end = in_next + in_nbytes;
-	const u8 *in_cur_base = in_next;
-	u32 max_len = DEFLATE_MAX_MATCH_LEN;
-	u32 nice_len = MIN(c->nice_match_length, max_len);
-	u32 next_hashes[2] = {0, 0};
-
-	hc_matchfinder_init(&c->p.g.hc_mf);
-
-	do {
-		/* Starting a new DEFLATE block */
-
-		const u8 * const in_block_begin = in_next;
-		const u8 * const in_max_block_end = choose_max_block_end(
-				in_next, in_end, SOFT_MAX_BLOCK_LENGTH);
-		struct deflate_sequence *seq = c->p.g.sequences;
-		u32 min_len;
-
-		init_block_split_stats(&c->split_stats);
-		deflate_begin_sequences(c, seq);
-		min_len = calculate_min_match_len(in_next,
-						  in_max_block_end - in_next,
-						  c->max_search_depth);
-		do {
-			u32 length;
-			u32 offset;
-
-			adjust_max_and_nice_len(&max_len, &nice_len,
-						in_end - in_next);
-			length = hc_matchfinder_longest_match(
-						&c->p.g.hc_mf,
-						&in_cur_base,
-						in_next,
-						min_len - 1,
-						max_len,
-						nice_len,
-						c->max_search_depth,
-						next_hashes,
-						&offset);
-
-			if (length >= min_len &&
-			    (length > DEFLATE_MIN_MATCH_LEN ||
-			     offset <= 4096)) {
-				/* Match found */
-				deflate_choose_match(c, length, offset, true,
-						     &seq);
-				hc_matchfinder_skip_bytes(&c->p.g.hc_mf,
-							  &in_cur_base,
-							  in_next + 1,
-							  in_end,
-							  length - 1,
-							  next_hashes);
-				in_next += length;
-			} else {
-				/* No match found */
-				deflate_choose_literal(c, *in_next++, true,
-						       seq);
-			}
-
-			/* Check if it's time to output another block. */
-		} while (in_next < in_max_block_end &&
-			 seq < &c->p.g.sequences[SEQ_STORE_LENGTH] &&
-			 !should_end_block(&c->split_stats,
-					   in_block_begin, in_next, in_end));
-
-		deflate_finish_block(c, os, in_block_begin,
-				     in_next - in_block_begin,
-				     c->p.g.sequences, in_next == in_end);
-	} while (in_next != in_end && !os->overflow);
-}
-
-static forceinline void
-deflate_compress_lazy_generic(struct libdeflate_compressor * restrict c,
-			      const u8 *in, size_t in_nbytes,
-			      struct deflate_output_bitstream *os, bool lazy2)
-{
-	const u8 *in_next = in;
-	const u8 *in_end = in_next + in_nbytes;
-	const u8 *in_cur_base = in_next;
-	u32 max_len = DEFLATE_MAX_MATCH_LEN;
-	u32 nice_len = MIN(c->nice_match_length, max_len);
-	u32 next_hashes[2] = {0, 0};
-
-	hc_matchfinder_init(&c->p.g.hc_mf);
-
-	do {
-		/* Starting a new DEFLATE block */
-
-		const u8 * const in_block_begin = in_next;
-		const u8 * const in_max_block_end = choose_max_block_end(
-				in_next, in_end, SOFT_MAX_BLOCK_LENGTH);
-		const u8 *next_recalc_min_len =
-			in_next + MIN(in_end - in_next, 10000);
-		struct deflate_sequence *seq = c->p.g.sequences;
-		u32 min_len;
-
-		init_block_split_stats(&c->split_stats);
-		deflate_begin_sequences(c, seq);
-		min_len = calculate_min_match_len(in_next,
-						  in_max_block_end - in_next,
-						  c->max_search_depth);
-		do {
-			u32 cur_len;
-			u32 cur_offset;
-			u32 next_len;
-			u32 next_offset;
-
-			/*
-			 * Recalculate the minimum match length if it hasn't
-			 * been done recently.
-			 */
-			if (in_next >= next_recalc_min_len) {
-				min_len = recalculate_min_match_len(
-						&c->freqs,
-						c->max_search_depth);
-				next_recalc_min_len +=
-					MIN(in_end - next_recalc_min_len,
-					    in_next - in_block_begin);
-			}
-
-			/* Find the longest match at the current position. */
-			adjust_max_and_nice_len(&max_len, &nice_len,
-						in_end - in_next);
-			cur_len = hc_matchfinder_longest_match(
-						&c->p.g.hc_mf,
-						&in_cur_base,
-						in_next,
-						min_len - 1,
-						max_len,
-						nice_len,
-						c->max_search_depth,
-						next_hashes,
-						&cur_offset);
-			if (cur_len < min_len ||
-			    (cur_len == DEFLATE_MIN_MATCH_LEN &&
-			     cur_offset > 8192)) {
-				/* No match found.  Choose a literal. */
-				deflate_choose_literal(c, *in_next++, true,
-						       seq);
-				continue;
-			}
-			in_next++;
-
-have_cur_match:
-			/*
-			 * We have a match at the current position.
-			 * If it's very long, choose it immediately.
-			 */
-			if (cur_len >= nice_len) {
-				deflate_choose_match(c, cur_len, cur_offset,
-						     true, &seq);
-				hc_matchfinder_skip_bytes(&c->p.g.hc_mf,
-							  &in_cur_base,
-							  in_next,
-							  in_end,
-							  cur_len - 1,
-							  next_hashes);
-				in_next += cur_len - 1;
-				continue;
-			}
-
-			/*
-			 * Try to find a better match at the next position.
-			 *
-			 * Note: since we already have a match at the *current*
-			 * position, we use only half the 'max_search_depth'
-			 * when checking the *next* position.  This is a useful
-			 * trade-off because it's more worthwhile to use a
-			 * greater search depth on the initial match.
-			 *
-			 * Note: it's possible to structure the code such that
-			 * there's only one call to longest_match(), which
-			 * handles both the "find the initial match" and "try to
-			 * find a better match" cases.  However, it is faster to
-			 * have two call sites, with longest_match() inlined at
-			 * each.
-			 */
-			adjust_max_and_nice_len(&max_len, &nice_len,
-						in_end - in_next);
-			next_len = hc_matchfinder_longest_match(
-						&c->p.g.hc_mf,
-						&in_cur_base,
-						in_next++,
-						cur_len - 1,
-						max_len,
-						nice_len,
-						c->max_search_depth >> 1,
-						next_hashes,
-						&next_offset);
-			if (next_len >= cur_len &&
-			    4 * (int)(next_len - cur_len) +
-			    ((int)bsr32(cur_offset) -
-			     (int)bsr32(next_offset)) > 2) {
-				/*
-				 * Found a better match at the next position.
-				 * Output a literal.  Then the next match
-				 * becomes the current match.
-				 */
-				deflate_choose_literal(c, *(in_next - 2), true,
-						       seq);
-				cur_len = next_len;
-				cur_offset = next_offset;
-				goto have_cur_match;
-			}
-
-			if (lazy2) {
-				/* In lazy2 mode, look ahead another position */
-				adjust_max_and_nice_len(&max_len, &nice_len,
-							in_end - in_next);
-				next_len = hc_matchfinder_longest_match(
-						&c->p.g.hc_mf,
-						&in_cur_base,
-						in_next++,
-						cur_len - 1,
-						max_len,
-						nice_len,
-						c->max_search_depth >> 2,
-						next_hashes,
-						&next_offset);
-				if (next_len >= cur_len &&
-				    4 * (int)(next_len - cur_len) +
-				    ((int)bsr32(cur_offset) -
-				     (int)bsr32(next_offset)) > 6) {
-					/*
-					 * There's a much better match two
-					 * positions ahead, so use two literals.
-					 */
-					deflate_choose_literal(
-						c, *(in_next - 3), true, seq);
-					deflate_choose_literal(
-						c, *(in_next - 2), true, seq);
-					cur_len = next_len;
-					cur_offset = next_offset;
-					goto have_cur_match;
-				}
-				/*
-				 * No better match at either of the next 2
-				 * positions.  Output the current match.
-				 */
-				deflate_choose_match(c, cur_len, cur_offset,
-						     true, &seq);
-				if (cur_len > 3) {
-					hc_matchfinder_skip_bytes(&c->p.g.hc_mf,
-								  &in_cur_base,
-								  in_next,
-								  in_end,
-								  cur_len - 3,
-								  next_hashes);
-					in_next += cur_len - 3;
-				}
-			} else { /* !lazy2 */
-				/*
-				 * No better match at the next position.  Output
-				 * the current match.
-				 */
-				deflate_choose_match(c, cur_len, cur_offset,
-						     true, &seq);
-				hc_matchfinder_skip_bytes(&c->p.g.hc_mf,
-							  &in_cur_base,
-							  in_next,
-							  in_end,
-							  cur_len - 2,
-							  next_hashes);
-				in_next += cur_len - 2;
-			}
-			/* Check if it's time to output another block. */
-		} while (in_next < in_max_block_end &&
-			 seq < &c->p.g.sequences[SEQ_STORE_LENGTH] &&
-			 !should_end_block(&c->split_stats,
-					   in_block_begin, in_next, in_end));
-
-		deflate_finish_block(c, os, in_block_begin,
-				     in_next - in_block_begin,
-				     c->p.g.sequences, in_next == in_end);
-	} while (in_next != in_end && !os->overflow);
-}
-
-/*
- * This is the "lazy" DEFLATE compressor.  Before choosing a match, it checks to
- * see if there's a better match at the next position.  If yes, it outputs a
- * literal and continues to the next position.  If no, it outputs the match.
- */
-static void
-deflate_compress_lazy(struct libdeflate_compressor * restrict c,
-		      const u8 *in, size_t in_nbytes,
-		      struct deflate_output_bitstream *os)
-{
-	deflate_compress_lazy_generic(c, in, in_nbytes, os, false);
-}
-
-/*
- * The lazy2 compressor.  This is similar to the regular lazy one, but it looks
- * for a better match at the next 2 positions rather than the next 1.  This
- * makes it take slightly more time, but compress some inputs slightly more.
- */
-static void
-deflate_compress_lazy2(struct libdeflate_compressor * restrict c,
-		       const u8 *in, size_t in_nbytes,
-		       struct deflate_output_bitstream *os)
-{
-	deflate_compress_lazy_generic(c, in, in_nbytes, os, true);
-}
-
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-
-/*
- * Follow the minimum-cost path in the graph of possible match/literal choices
- * for the current block and compute the frequencies of the Huffman symbols that
- * would be needed to output those matches and literals.
- */
-static void
-deflate_tally_item_list(struct libdeflate_compressor *c, u32 block_length)
-{
-	struct deflate_optimum_node *cur_node = &c->p.n.optimum_nodes[0];
-	struct deflate_optimum_node *end_node =
-		&c->p.n.optimum_nodes[block_length];
-
-	do {
-		u32 length = cur_node->item & OPTIMUM_LEN_MASK;
-		u32 offset = cur_node->item >> OPTIMUM_OFFSET_SHIFT;
-
-		if (length == 1) {
-			/* Literal */
-			c->freqs.litlen[offset]++;
-		} else {
-			/* Match */
-			c->freqs.litlen[DEFLATE_FIRST_LEN_SYM +
-					deflate_length_slot[length]]++;
-			c->freqs.offset[c->p.n.offset_slot_full[offset]]++;
-		}
-		cur_node += length;
-	} while (cur_node != end_node);
-
-	/* Tally the end-of-block symbol. */
-	c->freqs.litlen[DEFLATE_END_OF_BLOCK]++;
-}
-
-static void
-deflate_choose_all_literals(struct libdeflate_compressor *c,
-			    const u8 *block, u32 block_length)
-{
-	u32 i;
-
-	deflate_reset_symbol_frequencies(c);
-	for (i = 0; i < block_length; i++)
-		c->freqs.litlen[block[i]]++;
-	c->freqs.litlen[DEFLATE_END_OF_BLOCK]++;
-
-	deflate_make_huffman_codes(&c->freqs, &c->codes);
-}
-
-/*
- * Compute the exact cost, in bits, that would be required to output the matches
- * and literals described by @c->freqs as a dynamic Huffman block.  The litlen
- * and offset codes are assumed to have already been built in @c->codes.
- */
-static u32
-deflate_compute_true_cost(struct libdeflate_compressor *c)
-{
-	u32 cost = 0;
-	unsigned sym;
-
-	deflate_precompute_huffman_header(c);
-
-	memset(&c->codes.lens.litlen[c->o.precode.num_litlen_syms], 0,
-	       DEFLATE_NUM_LITLEN_SYMS - c->o.precode.num_litlen_syms);
-
-	cost += 5 + 5 + 4 + (3 * c->o.precode.num_explicit_lens);
-	for (sym = 0; sym < DEFLATE_NUM_PRECODE_SYMS; sym++) {
-		cost += c->o.precode.freqs[sym] *
-			(c->o.precode.lens[sym] +
-			 deflate_extra_precode_bits[sym]);
-	}
-
-	for (sym = 0; sym < DEFLATE_FIRST_LEN_SYM; sym++)
-		cost += c->freqs.litlen[sym] * c->codes.lens.litlen[sym];
-
-	for (; sym < DEFLATE_FIRST_LEN_SYM +
-	       ARRAY_LEN(deflate_extra_length_bits); sym++)
-		cost += c->freqs.litlen[sym] *
-			(c->codes.lens.litlen[sym] +
-			 deflate_extra_length_bits[sym - DEFLATE_FIRST_LEN_SYM]);
-
-	for (sym = 0; sym < ARRAY_LEN(deflate_extra_offset_bits); sym++)
-		cost += c->freqs.offset[sym] *
-			(c->codes.lens.offset[sym] +
-			 deflate_extra_offset_bits[sym]);
-	return cost;
-}
-
-/* Set the current cost model from the codeword lengths specified in @lens. */
-static void
-deflate_set_costs_from_codes(struct libdeflate_compressor *c,
-			     const struct deflate_lens *lens)
-{
-	unsigned i;
-
-	/* Literals */
-	for (i = 0; i < DEFLATE_NUM_LITERALS; i++) {
-		u32 bits = (lens->litlen[i] ?
-			    lens->litlen[i] : LITERAL_NOSTAT_BITS);
-
-		c->p.n.costs.literal[i] = bits * BIT_COST;
-	}
-
-	/* Lengths */
-	for (i = DEFLATE_MIN_MATCH_LEN; i <= DEFLATE_MAX_MATCH_LEN; i++) {
-		unsigned length_slot = deflate_length_slot[i];
-		unsigned litlen_sym = DEFLATE_FIRST_LEN_SYM + length_slot;
-		u32 bits = (lens->litlen[litlen_sym] ?
-			    lens->litlen[litlen_sym] : LENGTH_NOSTAT_BITS);
-
-		bits += deflate_extra_length_bits[length_slot];
-		c->p.n.costs.length[i] = bits * BIT_COST;
-	}
-
-	/* Offset slots */
-	for (i = 0; i < ARRAY_LEN(deflate_offset_slot_base); i++) {
-		u32 bits = (lens->offset[i] ?
-			    lens->offset[i] : OFFSET_NOSTAT_BITS);
-
-		bits += deflate_extra_offset_bits[i];
-		c->p.n.costs.offset_slot[i] = bits * BIT_COST;
-	}
-}
-
-/*
- * This lookup table gives the default cost of a literal symbol and of a length
- * symbol, depending on the characteristics of the input data.  It was generated
- * by scripts/gen_default_litlen_costs.py.
- *
- * This table is indexed first by the estimated match probability:
- *
- *	i=0: data doesn't contain many matches	[match_prob=0.25]
- *	i=1: neutral				[match_prob=0.50]
- *	i=2: data contains lots of matches	[match_prob=0.75]
- *
- * This lookup produces a subtable which maps the number of distinct used
- * literals to the default cost of a literal symbol, i.e.:
- *
- *	int(-log2((1 - match_prob) / num_used_literals) * BIT_COST)
- *
- * ... for num_used_literals in [1, 256] (and 0, which is copied from 1).  This
- * accounts for literals usually getting cheaper as the number of distinct
- * literals decreases, and as the proportion of literals to matches increases.
- *
- * The lookup also produces the cost of a length symbol, which is:
- *
- *	int(-log2(match_prob/NUM_LEN_SLOTS) * BIT_COST)
- *
- * Note: we don't currently assign different costs to different literal symbols,
- * or to different length symbols, as this is hard to do in a useful way.
- */
-static const struct {
-	u8 used_lits_to_lit_cost[257];
-	u8 len_sym_cost;
-} default_litlen_costs[] = {
-	{ /* match_prob = 0.25 */
-		.used_lits_to_lit_cost = {
-			6, 6, 22, 32, 38, 43, 48, 51,
-			54, 57, 59, 61, 64, 65, 67, 69,
-			70, 72, 73, 74, 75, 76, 77, 79,
-			80, 80, 81, 82, 83, 84, 85, 85,
-			86, 87, 88, 88, 89, 89, 90, 91,
-			91, 92, 92, 93, 93, 94, 95, 95,
-			96, 96, 96, 97, 97, 98, 98, 99,
-			99, 99, 100, 100, 101, 101, 101, 102,
-			102, 102, 103, 103, 104, 104, 104, 105,
-			105, 105, 105, 106, 106, 106, 107, 107,
-			107, 108, 108, 108, 108, 109, 109, 109,
-			109, 110, 110, 110, 111, 111, 111, 111,
-			112, 112, 112, 112, 112, 113, 113, 113,
-			113, 114, 114, 114, 114, 114, 115, 115,
-			115, 115, 115, 116, 116, 116, 116, 116,
-			117, 117, 117, 117, 117, 118, 118, 118,
-			118, 118, 118, 119, 119, 119, 119, 119,
-			120, 120, 120, 120, 120, 120, 121, 121,
-			121, 121, 121, 121, 121, 122, 122, 122,
-			122, 122, 122, 123, 123, 123, 123, 123,
-			123, 123, 124, 124, 124, 124, 124, 124,
-			124, 125, 125, 125, 125, 125, 125, 125,
-			125, 126, 126, 126, 126, 126, 126, 126,
-			127, 127, 127, 127, 127, 127, 127, 127,
-			128, 128, 128, 128, 128, 128, 128, 128,
-			128, 129, 129, 129, 129, 129, 129, 129,
-			129, 129, 130, 130, 130, 130, 130, 130,
-			130, 130, 130, 131, 131, 131, 131, 131,
-			131, 131, 131, 131, 131, 132, 132, 132,
-			132, 132, 132, 132, 132, 132, 132, 133,
-			133, 133, 133, 133, 133, 133, 133, 133,
-			133, 134, 134, 134, 134, 134, 134, 134,
-			134,
-		},
-		.len_sym_cost = 109,
-	}, { /* match_prob = 0.5 */
-		.used_lits_to_lit_cost = {
-			16, 16, 32, 41, 48, 53, 57, 60,
-			64, 66, 69, 71, 73, 75, 76, 78,
-			80, 81, 82, 83, 85, 86, 87, 88,
-			89, 90, 91, 92, 92, 93, 94, 95,
-			96, 96, 97, 98, 98, 99, 99, 100,
-			101, 101, 102, 102, 103, 103, 104, 104,
-			105, 105, 106, 106, 107, 107, 108, 108,
-			108, 109, 109, 110, 110, 110, 111, 111,
-			112, 112, 112, 113, 113, 113, 114, 114,
-			114, 115, 115, 115, 115, 116, 116, 116,
-			117, 117, 117, 118, 118, 118, 118, 119,
-			119, 119, 119, 120, 120, 120, 120, 121,
-			121, 121, 121, 122, 122, 122, 122, 122,
-			123, 123, 123, 123, 124, 124, 124, 124,
-			124, 125, 125, 125, 125, 125, 126, 126,
-			126, 126, 126, 127, 127, 127, 127, 127,
-			128, 128, 128, 128, 128, 128, 129, 129,
-			129, 129, 129, 129, 130, 130, 130, 130,
-			130, 130, 131, 131, 131, 131, 131, 131,
-			131, 132, 132, 132, 132, 132, 132, 133,
-			133, 133, 133, 133, 133, 133, 134, 134,
-			134, 134, 134, 134, 134, 134, 135, 135,
-			135, 135, 135, 135, 135, 135, 136, 136,
-			136, 136, 136, 136, 136, 136, 137, 137,
-			137, 137, 137, 137, 137, 137, 138, 138,
-			138, 138, 138, 138, 138, 138, 138, 139,
-			139, 139, 139, 139, 139, 139, 139, 139,
-			140, 140, 140, 140, 140, 140, 140, 140,
-			140, 141, 141, 141, 141, 141, 141, 141,
-			141, 141, 141, 142, 142, 142, 142, 142,
-			142, 142, 142, 142, 142, 142, 143, 143,
-			143, 143, 143, 143, 143, 143, 143, 143,
-			144,
-		},
-		.len_sym_cost = 93,
-	}, { /* match_prob = 0.75 */
-		.used_lits_to_lit_cost = {
-			32, 32, 48, 57, 64, 69, 73, 76,
-			80, 82, 85, 87, 89, 91, 92, 94,
-			96, 97, 98, 99, 101, 102, 103, 104,
-			105, 106, 107, 108, 108, 109, 110, 111,
-			112, 112, 113, 114, 114, 115, 115, 116,
-			117, 117, 118, 118, 119, 119, 120, 120,
-			121, 121, 122, 122, 123, 123, 124, 124,
-			124, 125, 125, 126, 126, 126, 127, 127,
-			128, 128, 128, 129, 129, 129, 130, 130,
-			130, 131, 131, 131, 131, 132, 132, 132,
-			133, 133, 133, 134, 134, 134, 134, 135,
-			135, 135, 135, 136, 136, 136, 136, 137,
-			137, 137, 137, 138, 138, 138, 138, 138,
-			139, 139, 139, 139, 140, 140, 140, 140,
-			140, 141, 141, 141, 141, 141, 142, 142,
-			142, 142, 142, 143, 143, 143, 143, 143,
-			144, 144, 144, 144, 144, 144, 145, 145,
-			145, 145, 145, 145, 146, 146, 146, 146,
-			146, 146, 147, 147, 147, 147, 147, 147,
-			147, 148, 148, 148, 148, 148, 148, 149,
-			149, 149, 149, 149, 149, 149, 150, 150,
-			150, 150, 150, 150, 150, 150, 151, 151,
-			151, 151, 151, 151, 151, 151, 152, 152,
-			152, 152, 152, 152, 152, 152, 153, 153,
-			153, 153, 153, 153, 153, 153, 154, 154,
-			154, 154, 154, 154, 154, 154, 154, 155,
-			155, 155, 155, 155, 155, 155, 155, 155,
-			156, 156, 156, 156, 156, 156, 156, 156,
-			156, 157, 157, 157, 157, 157, 157, 157,
-			157, 157, 157, 158, 158, 158, 158, 158,
-			158, 158, 158, 158, 158, 158, 159, 159,
-			159, 159, 159, 159, 159, 159, 159, 159,
-			160,
-		},
-		.len_sym_cost = 84,
-	},
-};
-
-/*
- * Choose the default costs for literal and length symbols.  These symbols are
- * both part of the litlen alphabet.
- */
-static void
-deflate_choose_default_litlen_costs(struct libdeflate_compressor *c,
-				    const u8 *block_begin, u32 block_length,
-				    u32 *lit_cost, u32 *len_sym_cost)
-{
-	u32 num_used_literals = 0;
-	u32 literal_freq = block_length;
-	u32 match_freq = 0;
-	u32 cutoff;
-	u32 i;
-
-	/* Calculate the number of distinct literals that exist in the data. */
-	memset(c->freqs.litlen, 0,
-	       DEFLATE_NUM_LITERALS * sizeof(c->freqs.litlen[0]));
-	cutoff = literal_freq >> 11; /* Ignore literals used very rarely. */
-	for (i = 0; i < block_length; i++)
-		c->freqs.litlen[block_begin[i]]++;
-	for (i = 0; i < DEFLATE_NUM_LITERALS; i++) {
-		if (c->freqs.litlen[i] > cutoff)
-			num_used_literals++;
-	}
-	if (num_used_literals == 0)
-		num_used_literals = 1;
-
-	/*
-	 * Estimate the relative frequency of literals and matches in the
-	 * optimal parsing solution.  We don't know the optimal solution, so
-	 * this can only be a very rough estimate.  Therefore, we basically use
-	 * the match frequency from a greedy parse.  We also apply the min_len
-	 * heuristic used by the greedy and lazy parsers, to avoid counting too
-	 * many matches when literals are cheaper than short matches.
-	 */
-	match_freq = 0;
-	i = choose_min_match_len(num_used_literals, c->max_search_depth);
-	for (; i < ARRAY_LEN(c->p.n.match_len_freqs); i++) {
-		match_freq += c->p.n.match_len_freqs[i];
-		literal_freq -= i * c->p.n.match_len_freqs[i];
-	}
-	if ((s32)literal_freq < 0) /* shouldn't happen */
-		literal_freq = 0;
-
-	if (match_freq > literal_freq)
-		i = 2; /* many matches */
-	else if (match_freq * 4 > literal_freq)
-		i = 1; /* neutral */
-	else
-		i = 0; /* few matches */
-
-	STATIC_ASSERT(BIT_COST == 16);
-	*lit_cost = default_litlen_costs[i].used_lits_to_lit_cost[
-							num_used_literals];
-	*len_sym_cost = default_litlen_costs[i].len_sym_cost;
-}
-
-static forceinline u32
-deflate_default_length_cost(u32 len, u32 len_sym_cost)
-{
-	unsigned slot = deflate_length_slot[len];
-	u32 num_extra_bits = deflate_extra_length_bits[slot];
-
-	return len_sym_cost + (num_extra_bits * BIT_COST);
-}
-
-static forceinline u32
-deflate_default_offset_slot_cost(unsigned slot)
-{
-	u32 num_extra_bits = deflate_extra_offset_bits[slot];
-	/*
-	 * Assume that all offset symbols are equally probable.
-	 * The resulting cost is 'int(-log2(1/30) * BIT_COST)',
-	 * where 30 is the number of potentially-used offset symbols.
-	 */
-	u32 offset_sym_cost = 4*BIT_COST + (907*BIT_COST)/1000;
-
-	return offset_sym_cost + (num_extra_bits * BIT_COST);
-}
-
-/* Set default symbol costs for the first block's first optimization pass. */
-static void
-deflate_set_default_costs(struct libdeflate_compressor *c,
-			  u32 lit_cost, u32 len_sym_cost)
-{
-	u32 i;
-
-	/* Literals */
-	for (i = 0; i < DEFLATE_NUM_LITERALS; i++)
-		c->p.n.costs.literal[i] = lit_cost;
-
-	/* Lengths */
-	for (i = DEFLATE_MIN_MATCH_LEN; i <= DEFLATE_MAX_MATCH_LEN; i++)
-		c->p.n.costs.length[i] =
-			deflate_default_length_cost(i, len_sym_cost);
-
-	/* Offset slots */
-	for (i = 0; i < ARRAY_LEN(deflate_offset_slot_base); i++)
-		c->p.n.costs.offset_slot[i] =
-			deflate_default_offset_slot_cost(i);
-}
-
-static forceinline void
-deflate_adjust_cost(u32 *cost_p, u32 default_cost, int change_amount)
-{
-	if (change_amount == 0)
-		/* Block is very similar to previous; prefer previous costs. */
-		*cost_p = (default_cost + 3 * *cost_p) / 4;
-	else if (change_amount == 1)
-		*cost_p = (default_cost + *cost_p) / 2;
-	else if (change_amount == 2)
-		*cost_p = (5 * default_cost + 3 * *cost_p) / 8;
-	else
-		/* Block differs greatly from previous; prefer default costs. */
-		*cost_p = (3 * default_cost + *cost_p) / 4;
-}
-
-static forceinline void
-deflate_adjust_costs_impl(struct libdeflate_compressor *c,
-			  u32 lit_cost, u32 len_sym_cost, int change_amount)
-{
-	u32 i;
-
-	/* Literals */
-	for (i = 0; i < DEFLATE_NUM_LITERALS; i++)
-		deflate_adjust_cost(&c->p.n.costs.literal[i], lit_cost,
-				    change_amount);
-
-	/* Lengths */
-	for (i = DEFLATE_MIN_MATCH_LEN; i <= DEFLATE_MAX_MATCH_LEN; i++)
-		deflate_adjust_cost(&c->p.n.costs.length[i],
-				    deflate_default_length_cost(i,
-								len_sym_cost),
-				    change_amount);
-
-	/* Offset slots */
-	for (i = 0; i < ARRAY_LEN(deflate_offset_slot_base); i++)
-		deflate_adjust_cost(&c->p.n.costs.offset_slot[i],
-				    deflate_default_offset_slot_cost(i),
-				    change_amount);
-}
-
-/*
- * Adjust the costs when beginning a new block.
- *
- * Since the current costs are optimized for the data already, it can be helpful
- * to reuse them instead of starting over with the default costs.  However, this
- * depends on how similar the new block is to the previous block.  Therefore,
- * use a heuristic to decide how similar the blocks are, and mix together the
- * current costs and the default costs accordingly.
- */
-static void
-deflate_adjust_costs(struct libdeflate_compressor *c,
-		     u32 lit_cost, u32 len_sym_cost)
-{
-	u64 total_delta = 0;
-	u64 cutoff;
-	int i;
-
-	/*
-	 * Decide how different the current block is from the previous block,
-	 * using the block splitting statistics from the current and previous
-	 * blocks.  The more different the current block is, the more we prefer
-	 * the default costs rather than the previous block's costs.
-	 *
-	 * The algorithm here is similar to the end-of-block check one, but here
-	 * we compare two entire blocks rather than a partial block with a small
-	 * extra part, and therefore we need 64-bit numbers in some places.
-	 */
-	for (i = 0; i < NUM_OBSERVATION_TYPES; i++) {
-		u64 prev = (u64)c->p.n.prev_observations[i] *
-			    c->split_stats.num_observations;
-		u64 cur = (u64)c->split_stats.observations[i] *
-			  c->p.n.prev_num_observations;
-
-		total_delta += prev > cur ? prev - cur : cur - prev;
-	}
-	cutoff = ((u64)c->p.n.prev_num_observations *
-		  c->split_stats.num_observations * 200) / 512;
-
-	if (total_delta > 3 * cutoff)
-		/* Big change in the data; just use the default costs. */
-		deflate_set_default_costs(c, lit_cost, len_sym_cost);
-	else if (4 * total_delta > 9 * cutoff)
-		deflate_adjust_costs_impl(c, lit_cost, len_sym_cost, 3);
-	else if (2 * total_delta > 3 * cutoff)
-		deflate_adjust_costs_impl(c, lit_cost, len_sym_cost, 2);
-	else if (2 * total_delta > cutoff)
-		deflate_adjust_costs_impl(c, lit_cost, len_sym_cost, 1);
-	else
-		deflate_adjust_costs_impl(c, lit_cost, len_sym_cost, 0);
-}
-
-static void
-deflate_set_initial_costs(struct libdeflate_compressor *c,
-			  const u8 *block_begin, u32 block_length,
-			  bool is_first_block)
-{
-	u32 lit_cost, len_sym_cost;
-
-	deflate_choose_default_litlen_costs(c, block_begin, block_length,
-					    &lit_cost, &len_sym_cost);
-	if (is_first_block)
-		deflate_set_default_costs(c, lit_cost, len_sym_cost);
-	else
-		deflate_adjust_costs(c, lit_cost, len_sym_cost);
-}
-
-/*
- * Find the minimum-cost path through the graph of possible match/literal
- * choices for this block.
- *
- * We find the minimum cost path from 'c->p.n.optimum_nodes[0]', which
- * represents the node at the beginning of the block, to
- * 'c->p.n.optimum_nodes[block_length]', which represents the node at the end of
- * the block.  Edge costs are evaluated using the cost model 'c->p.n.costs'.
- *
- * The algorithm works backwards, starting at the end node and proceeding
- * backwards one node at a time.  At each node, the minimum cost to reach the
- * end node is computed and the match/literal choice that begins that path is
- * saved.
- */
-static void
-deflate_find_min_cost_path(struct libdeflate_compressor *c,
-			   const u32 block_length,
-			   const struct lz_match *cache_ptr)
-{
-	struct deflate_optimum_node *end_node =
-		&c->p.n.optimum_nodes[block_length];
-	struct deflate_optimum_node *cur_node = end_node;
-
-	cur_node->cost_to_end = 0;
-	do {
-		unsigned num_matches;
-		u32 literal;
-		u32 best_cost_to_end;
-
-		cur_node--;
-		cache_ptr--;
-
-		num_matches = cache_ptr->length;
-		literal = cache_ptr->offset;
-
-		/* It's always possible to choose a literal. */
-		best_cost_to_end = c->p.n.costs.literal[literal] +
-				   (cur_node + 1)->cost_to_end;
-		cur_node->item = (literal << OPTIMUM_OFFSET_SHIFT) | 1;
-
-		/* Also consider matches if there are any. */
-		if (num_matches) {
-			const struct lz_match *match;
-			u32 len;
-			u32 offset;
-			u32 offset_slot;
-			u32 offset_cost;
-			u32 cost_to_end;
-
-			/*
-			 * Consider each length from the minimum
-			 * (DEFLATE_MIN_MATCH_LEN) to the length of the longest
-			 * match found at this position.  For each length, we
-			 * consider only the smallest offset for which that
-			 * length is available.  Although this is not guaranteed
-			 * to be optimal due to the possibility of a larger
-			 * offset costing less than a smaller offset to code,
-			 * this is a very useful heuristic.
-			 */
-			match = cache_ptr - num_matches;
-			len = DEFLATE_MIN_MATCH_LEN;
-			do {
-				offset = match->offset;
-				offset_slot = c->p.n.offset_slot_full[offset];
-				offset_cost =
-					c->p.n.costs.offset_slot[offset_slot];
-				do {
-					cost_to_end = offset_cost +
-						c->p.n.costs.length[len] +
-						(cur_node + len)->cost_to_end;
-					if (cost_to_end < best_cost_to_end) {
-						best_cost_to_end = cost_to_end;
-						cur_node->item = len |
-							(offset <<
-							 OPTIMUM_OFFSET_SHIFT);
-					}
-				} while (++len <= match->length);
-			} while (++match != cache_ptr);
-			cache_ptr -= num_matches;
-		}
-		cur_node->cost_to_end = best_cost_to_end;
-	} while (cur_node != &c->p.n.optimum_nodes[0]);
-
-	deflate_reset_symbol_frequencies(c);
-	deflate_tally_item_list(c, block_length);
-	deflate_make_huffman_codes(&c->freqs, &c->codes);
-}
-
-/*
- * Choose the literals and matches for the current block, then output the block.
- *
- * To choose the literal/match sequence, we find the minimum-cost path through
- * the block's graph of literal/match choices, given a cost model.  However, the
- * true cost of each symbol is unknown until the Huffman codes have been built,
- * but at the same time the Huffman codes depend on the frequencies of chosen
- * symbols.  Consequently, multiple passes must be used to try to approximate an
- * optimal solution.  The first pass uses default costs, mixed with the costs
- * from the previous block when it seems appropriate.  Later passes use the
- * Huffman codeword lengths from the previous pass as the costs.
- *
- * As an alternate strategy, also consider using only literals.  The boolean
- * returned in *used_only_literals indicates whether that strategy was best.
- */
-static void
-deflate_optimize_and_flush_block(struct libdeflate_compressor *c,
-				 struct deflate_output_bitstream *os,
-				 const u8 *block_begin, u32 block_length,
-				 const struct lz_match *cache_ptr,
-				 bool is_first_block, bool is_final_block,
-				 bool *used_only_literals)
-{
-	unsigned num_passes_remaining = c->p.n.max_optim_passes;
-	u32 best_true_cost = UINT32_MAX;
-	u32 true_cost;
-	u32 only_lits_cost;
-	u32 static_cost = UINT32_MAX;
-	struct deflate_sequence seq_;
-	struct deflate_sequence *seq = NULL;
-	u32 i;
-
-	/*
-	 * On some data, using only literals (no matches) ends up being better
-	 * than what the iterative optimization algorithm produces.  Therefore,
-	 * consider using only literals.
-	 */
-	deflate_choose_all_literals(c, block_begin, block_length);
-	only_lits_cost = deflate_compute_true_cost(c);
-
-	/*
-	 * Force the block to really end at the desired length, even if some
-	 * matches extend beyond it.
-	 */
-	for (i = block_length;
-	     i <= MIN(block_length - 1 + DEFLATE_MAX_MATCH_LEN,
-		      ARRAY_LEN(c->p.n.optimum_nodes) - 1); i++)
-		c->p.n.optimum_nodes[i].cost_to_end = 0x80000000;
-
-	/*
-	 * Sometimes a static Huffman block ends up being cheapest, particularly
-	 * if the block is small.  So, if the block is sufficiently small, find
-	 * the optimal static block solution and remember its cost.
-	 */
-	if (block_length <= c->p.n.max_len_to_optimize_static_block) {
-		/* Save c->p.n.costs temporarily. */
-		c->p.n.costs_saved = c->p.n.costs;
-
-		deflate_set_costs_from_codes(c, &c->static_codes.lens);
-		deflate_find_min_cost_path(c, block_length, cache_ptr);
-		static_cost = c->p.n.optimum_nodes[0].cost_to_end / BIT_COST;
-		static_cost += 7; /* for the end-of-block symbol */
-
-		/* Restore c->p.n.costs. */
-		c->p.n.costs = c->p.n.costs_saved;
-	}
-
-	/* Initialize c->p.n.costs with default costs. */
-	deflate_set_initial_costs(c, block_begin, block_length, is_first_block);
-
-	do {
-		/*
-		 * Find the minimum-cost path for this pass.
-		 * Also set c->freqs and c->codes to match the path.
-		 */
-		deflate_find_min_cost_path(c, block_length, cache_ptr);
-
-		/*
-		 * Compute the exact cost of the block if the path were to be
-		 * used.  Note that this differs from
-		 * c->p.n.optimum_nodes[0].cost_to_end in that true_cost uses
-		 * the actual Huffman codes instead of c->p.n.costs.
-		 */
-		true_cost = deflate_compute_true_cost(c);
-
-		/*
-		 * If the cost didn't improve much from the previous pass, then
-		 * doing more passes probably won't be helpful, so stop early.
-		 */
-		if (true_cost + c->p.n.min_improvement_to_continue >
-		    best_true_cost)
-			break;
-
-		best_true_cost = true_cost;
-
-		/* Save the cost model that gave 'best_true_cost'. */
-		c->p.n.costs_saved = c->p.n.costs;
-
-		/* Update the cost model from the Huffman codes. */
-		deflate_set_costs_from_codes(c, &c->codes.lens);
-
-	} while (--num_passes_remaining);
-
-	*used_only_literals = false;
-	if (MIN(only_lits_cost, static_cost) < best_true_cost) {
-		if (only_lits_cost < static_cost) {
-			/* Using only literals ended up being best! */
-			deflate_choose_all_literals(c, block_begin, block_length);
-			deflate_set_costs_from_codes(c, &c->codes.lens);
-			seq_.litrunlen_and_length = block_length;
-			seq = &seq_;
-			*used_only_literals = true;
-		} else {
-			/* Static block ended up being best! */
-			deflate_set_costs_from_codes(c, &c->static_codes.lens);
-			deflate_find_min_cost_path(c, block_length, cache_ptr);
-		}
-	} else if (true_cost >=
-		   best_true_cost + c->p.n.min_bits_to_use_nonfinal_path) {
-		/*
-		 * The best solution was actually from a non-final optimization
-		 * pass, so recover and use the min-cost path from that pass.
-		 */
-		c->p.n.costs = c->p.n.costs_saved;
-		deflate_find_min_cost_path(c, block_length, cache_ptr);
-		deflate_set_costs_from_codes(c, &c->codes.lens);
-	}
-	deflate_flush_block(c, os, block_begin, block_length, seq,
-			    is_final_block);
-}
-
-static void
-deflate_near_optimal_init_stats(struct libdeflate_compressor *c)
-{
-	init_block_split_stats(&c->split_stats);
-	memset(c->p.n.new_match_len_freqs, 0,
-	       sizeof(c->p.n.new_match_len_freqs));
-	memset(c->p.n.match_len_freqs, 0, sizeof(c->p.n.match_len_freqs));
-}
-
-static void
-deflate_near_optimal_merge_stats(struct libdeflate_compressor *c)
-{
-	unsigned i;
-
-	merge_new_observations(&c->split_stats);
-	for (i = 0; i < ARRAY_LEN(c->p.n.match_len_freqs); i++) {
-		c->p.n.match_len_freqs[i] += c->p.n.new_match_len_freqs[i];
-		c->p.n.new_match_len_freqs[i] = 0;
-	}
-}
-
-/*
- * Save some literal/match statistics from the previous block so that
- * deflate_adjust_costs() will be able to decide how much the current block
- * differs from the previous one.
- */
-static void
-deflate_near_optimal_save_stats(struct libdeflate_compressor *c)
-{
-	int i;
-
-	for (i = 0; i < NUM_OBSERVATION_TYPES; i++)
-		c->p.n.prev_observations[i] = c->split_stats.observations[i];
-	c->p.n.prev_num_observations = c->split_stats.num_observations;
-}
-
-static void
-deflate_near_optimal_clear_old_stats(struct libdeflate_compressor *c)
-{
-	int i;
-
-	for (i = 0; i < NUM_OBSERVATION_TYPES; i++)
-		c->split_stats.observations[i] = 0;
-	c->split_stats.num_observations = 0;
-	memset(c->p.n.match_len_freqs, 0, sizeof(c->p.n.match_len_freqs));
-}
-
-/*
- * This is the "near-optimal" DEFLATE compressor.  It computes the optimal
- * representation of each DEFLATE block using a minimum-cost path search over
- * the graph of possible match/literal choices for that block, assuming a
- * certain cost for each Huffman symbol.
- *
- * For several reasons, the end result is not guaranteed to be optimal:
- *
- * - Nonoptimal choice of blocks
- * - Heuristic limitations on which matches are actually considered
- * - Symbol costs are unknown until the symbols have already been chosen
- *   (so iterative optimization must be used)
- */
-static void
-deflate_compress_near_optimal(struct libdeflate_compressor * restrict c,
-			      const u8 *in, size_t in_nbytes,
-			      struct deflate_output_bitstream *os)
-{
-	const u8 *in_next = in;
-	const u8 *in_block_begin = in_next;
-	const u8 *in_end = in_next + in_nbytes;
-	const u8 *in_cur_base = in_next;
-	const u8 *in_next_slide =
-		in_next + MIN(in_end - in_next, MATCHFINDER_WINDOW_SIZE);
-	u32 max_len = DEFLATE_MAX_MATCH_LEN;
-	u32 nice_len = MIN(c->nice_match_length, max_len);
-	struct lz_match *cache_ptr = c->p.n.match_cache;
-	u32 next_hashes[2] = {0, 0};
-	bool prev_block_used_only_literals = false;
-
-	bt_matchfinder_init(&c->p.n.bt_mf);
-	deflate_near_optimal_init_stats(c);
-
-	do {
-		/* Starting a new DEFLATE block */
-		const u8 * const in_max_block_end = choose_max_block_end(
-				in_block_begin, in_end, SOFT_MAX_BLOCK_LENGTH);
-		const u8 *prev_end_block_check = NULL;
-		bool change_detected = false;
-		const u8 *next_observation = in_next;
-		u32 min_len;
-
-		/*
-		 * Use the minimum match length heuristic to improve the
-		 * literal/match statistics gathered during matchfinding.
-		 * However, the actual near-optimal parse won't respect min_len,
-		 * as it can accurately assess the costs of different matches.
-		 *
-		 * If the "use only literals" strategy happened to be the best
-		 * strategy on the previous block, then probably the
-		 * min_match_len heuristic is still not aggressive enough for
-		 * the data, so force gathering literal stats only.
-		 */
-		if (prev_block_used_only_literals)
-			min_len = DEFLATE_MAX_MATCH_LEN + 1;
-		else
-			min_len = calculate_min_match_len(
-					in_block_begin,
-					in_max_block_end - in_block_begin,
-					c->max_search_depth);
-
-		/*
-		 * Find matches until we decide to end the block.  We end the
-		 * block if any of the following is true:
-		 *
-		 * (1) Maximum block length has been reached
-		 * (2) Match catch may overflow.
-		 * (3) Block split heuristic says to split now.
-		 */
-		for (;;) {
-			struct lz_match *matches;
-			u32 best_len;
-			size_t remaining = in_end - in_next;
-
-			/* Slide the window forward if needed. */
-			if (in_next == in_next_slide) {
-				bt_matchfinder_slide_window(&c->p.n.bt_mf);
-				in_cur_base = in_next;
-				in_next_slide = in_next +
-					MIN(remaining, MATCHFINDER_WINDOW_SIZE);
-			}
-
-			/*
-			 * Find matches with the current position using the
-			 * binary tree matchfinder and save them in match_cache.
-			 *
-			 * Note: the binary tree matchfinder is more suited for
-			 * optimal parsing than the hash chain matchfinder.  The
-			 * reasons for this include:
-			 *
-			 * - The binary tree matchfinder can find more matches
-			 *   in the same number of steps.
-			 * - One of the major advantages of hash chains is that
-			 *   skipping positions (not searching for matches at
-			 *   them) is faster; however, with optimal parsing we
-			 *   search for matches at almost all positions, so this
-			 *   advantage of hash chains is negated.
-			 */
-			matches = cache_ptr;
-			best_len = 0;
-			adjust_max_and_nice_len(&max_len, &nice_len, remaining);
-			if (likely(max_len >= BT_MATCHFINDER_REQUIRED_NBYTES)) {
-				cache_ptr = bt_matchfinder_get_matches(
-						&c->p.n.bt_mf,
-						in_cur_base,
-						in_next - in_cur_base,
-						max_len,
-						nice_len,
-						c->max_search_depth,
-						next_hashes,
-						matches);
-				if (cache_ptr > matches)
-					best_len = cache_ptr[-1].length;
-			}
-			if (in_next >= next_observation) {
-				if (best_len >= min_len) {
-					observe_match(&c->split_stats,
-						      best_len);
-					next_observation = in_next + best_len;
-					c->p.n.new_match_len_freqs[best_len]++;
-				} else {
-					observe_literal(&c->split_stats,
-							*in_next);
-					next_observation = in_next + 1;
-				}
-			}
-
-			cache_ptr->length = cache_ptr - matches;
-			cache_ptr->offset = *in_next;
-			in_next++;
-			cache_ptr++;
-
-			/*
-			 * If there was a very long match found, don't cache any
-			 * matches for the bytes covered by that match.  This
-			 * avoids degenerate behavior when compressing highly
-			 * redundant data, where the number of matches can be
-			 * very large.
-			 *
-			 * This heuristic doesn't actually hurt the compression
-			 * ratio very much.  If there's a long match, then the
-			 * data must be highly compressible, so it doesn't
-			 * matter much what we do.
-			 */
-			if (best_len >= DEFLATE_MIN_MATCH_LEN &&
-			    best_len >= nice_len) {
-				--best_len;
-				do {
-					remaining = in_end - in_next;
-					if (in_next == in_next_slide) {
-						bt_matchfinder_slide_window(
-							&c->p.n.bt_mf);
-						in_cur_base = in_next;
-						in_next_slide = in_next +
-							MIN(remaining,
-							    MATCHFINDER_WINDOW_SIZE);
-					}
-					adjust_max_and_nice_len(&max_len,
-								&nice_len,
-								remaining);
-					if (max_len >=
-					    BT_MATCHFINDER_REQUIRED_NBYTES) {
-						bt_matchfinder_skip_byte(
-							&c->p.n.bt_mf,
-							in_cur_base,
-							in_next - in_cur_base,
-							nice_len,
-							c->max_search_depth,
-							next_hashes);
-					}
-					cache_ptr->length = 0;
-					cache_ptr->offset = *in_next;
-					in_next++;
-					cache_ptr++;
-				} while (--best_len);
-			}
-			/* Maximum block length or end of input reached? */
-			if (in_next >= in_max_block_end)
-				break;
-			/* Match cache overflowed? */
-			if (cache_ptr >=
-			    &c->p.n.match_cache[MATCH_CACHE_LENGTH])
-				break;
-			/* Not ready to try to end the block (again)? */
-			if (!ready_to_check_block(&c->split_stats,
-						  in_block_begin, in_next,
-						  in_end))
-				continue;
-			/* Check if it would be worthwhile to end the block. */
-			if (do_end_block_check(&c->split_stats,
-					       in_next - in_block_begin)) {
-				change_detected = true;
-				break;
-			}
-			/* Ending the block doesn't seem worthwhile here. */
-			deflate_near_optimal_merge_stats(c);
-			prev_end_block_check = in_next;
-		}
-		/*
-		 * All the matches for this block have been cached.  Now choose
-		 * the precise end of the block and the sequence of items to
-		 * output to represent it, then flush the block.
-		 */
-		if (change_detected && prev_end_block_check != NULL) {
-			/*
-			 * The block is being ended because a recent chunk of
-			 * data differs from the rest of the block.  We could
-			 * end the block at 'in_next' like the greedy and lazy
-			 * compressors do, but that's not ideal since it would
-			 * include the differing chunk in the block.  The
-			 * near-optimal compressor has time to do a better job.
-			 * Therefore, we rewind to just before the chunk, and
-			 * output a block that only goes up to there.
-			 *
-			 * We then set things up to correctly start the next
-			 * block, considering that some work has already been
-			 * done on it (some matches found and stats gathered).
-			 */
-			struct lz_match *orig_cache_ptr = cache_ptr;
-			const u8 *in_block_end = prev_end_block_check;
-			u32 block_length = in_block_end - in_block_begin;
-			bool is_first = (in_block_begin == in);
-			bool is_final = false;
-			u32 num_bytes_to_rewind = in_next - in_block_end;
-			size_t cache_len_rewound;
-
-			/* Rewind the match cache. */
-			do {
-				cache_ptr--;
-				cache_ptr -= cache_ptr->length;
-			} while (--num_bytes_to_rewind);
-			cache_len_rewound = orig_cache_ptr - cache_ptr;
-
-			deflate_optimize_and_flush_block(
-						c, os, in_block_begin,
-						block_length, cache_ptr,
-						is_first, is_final,
-						&prev_block_used_only_literals);
-			memmove(c->p.n.match_cache, cache_ptr,
-				cache_len_rewound * sizeof(*cache_ptr));
-			cache_ptr = &c->p.n.match_cache[cache_len_rewound];
-			deflate_near_optimal_save_stats(c);
-			/*
-			 * Clear the stats for the just-flushed block, leaving
-			 * just the stats for the beginning of the next block.
-			 */
-			deflate_near_optimal_clear_old_stats(c);
-			in_block_begin = in_block_end;
-		} else {
-			/*
-			 * The block is being ended for a reason other than a
-			 * differing data chunk being detected.  Don't rewind at
-			 * all; just end the block at the current position.
-			 */
-			u32 block_length = in_next - in_block_begin;
-			bool is_first = (in_block_begin == in);
-			bool is_final = (in_next == in_end);
-
-			deflate_near_optimal_merge_stats(c);
-			deflate_optimize_and_flush_block(
-						c, os, in_block_begin,
-						block_length, cache_ptr,
-						is_first, is_final,
-						&prev_block_used_only_literals);
-			cache_ptr = &c->p.n.match_cache[0];
-			deflate_near_optimal_save_stats(c);
-			deflate_near_optimal_init_stats(c);
-			in_block_begin = in_next;
-		}
-	} while (in_next != in_end && !os->overflow);
-}
-
-/* Initialize c->p.n.offset_slot_full. */
-static void
-deflate_init_offset_slot_full(struct libdeflate_compressor *c)
-{
-	u32 offset_slot;
-	u32 offset;
-	u32 offset_end;
-
-	for (offset_slot = 0; offset_slot < ARRAY_LEN(deflate_offset_slot_base);
-	     offset_slot++) {
-		offset = deflate_offset_slot_base[offset_slot];
-		offset_end = offset +
-			     (1 << deflate_extra_offset_bits[offset_slot]);
-		do {
-			c->p.n.offset_slot_full[offset] = offset_slot;
-		} while (++offset != offset_end);
-	}
-}
-
-#endif /* SUPPORT_NEAR_OPTIMAL_PARSING */
-
-LIBDEFLATEAPI struct libdeflate_compressor *
-libdeflate_alloc_compressor_ex(int compression_level,
-			       const struct libdeflate_options *options)
-{
-	struct libdeflate_compressor *c;
-	size_t size = offsetof(struct libdeflate_compressor, p);
-
-	check_buildtime_parameters();
-
-	/*
-	 * Note: if more fields are added to libdeflate_options, this code will
-	 * need to be updated to support both the old and new structs.
-	 */
-	if (options->sizeof_options != sizeof(*options))
-		return NULL;
-
-	/*
-	 * Note: For similarity with zlib's API, -1 is accepted as an alias for
-	 * the default compression level.
-	 */
-	if (compression_level == -1)
-		compression_level = 6;
-
-	if (compression_level < 0 || compression_level > 12)
-		return NULL;
-
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-	if (compression_level >= 10)
-		size += sizeof(c->p.n);
-	else
-#endif
-	{
-		if (compression_level >= 2)
-			size += sizeof(c->p.g);
-		else if (compression_level == 1)
-			size += sizeof(c->p.f);
-	}
-
-	c = libdeflate_aligned_malloc(options->malloc_func ?
-				      options->malloc_func :
-				      libdeflate_default_malloc_func,
-				      MATCHFINDER_MEM_ALIGNMENT, size);
-	if (!c)
-		return NULL;
-	c->free_func = options->free_func ?
-		       options->free_func : libdeflate_default_free_func;
-
-	c->compression_level = compression_level;
-
-	/*
-	 * The higher the compression level, the more we should bother trying to
-	 * compress very small inputs.
-	 */
-	c->max_passthrough_size = 55 - (compression_level * 4);
-
-	switch (compression_level) {
-	case 0:
-		c->max_passthrough_size = SIZE_MAX;
-		c->impl = NULL; /* not used */
-		break;
-	case 1:
-		c->impl = deflate_compress_fastest;
-		/* max_search_depth is unused. */
-		c->nice_match_length = 32;
-		break;
-	case 2:
-		c->impl = deflate_compress_greedy;
-		c->max_search_depth = 6;
-		c->nice_match_length = 10;
-		break;
-	case 3:
-		c->impl = deflate_compress_greedy;
-		c->max_search_depth = 12;
-		c->nice_match_length = 14;
-		break;
-	case 4:
-		c->impl = deflate_compress_greedy;
-		c->max_search_depth = 16;
-		c->nice_match_length = 30;
-		break;
-	case 5:
-		c->impl = deflate_compress_lazy;
-		c->max_search_depth = 16;
-		c->nice_match_length = 30;
-		break;
-	case 6:
-		c->impl = deflate_compress_lazy;
-		c->max_search_depth = 35;
-		c->nice_match_length = 65;
-		break;
-	case 7:
-		c->impl = deflate_compress_lazy;
-		c->max_search_depth = 100;
-		c->nice_match_length = 130;
-		break;
-	case 8:
-		c->impl = deflate_compress_lazy2;
-		c->max_search_depth = 300;
-		c->nice_match_length = DEFLATE_MAX_MATCH_LEN;
-		break;
-	case 9:
-#if !SUPPORT_NEAR_OPTIMAL_PARSING
-	default:
-#endif
-		c->impl = deflate_compress_lazy2;
-		c->max_search_depth = 600;
-		c->nice_match_length = DEFLATE_MAX_MATCH_LEN;
-		break;
-#if SUPPORT_NEAR_OPTIMAL_PARSING
-	case 10:
-		c->impl = deflate_compress_near_optimal;
-		c->max_search_depth = 35;
-		c->nice_match_length = 75;
-		c->p.n.max_optim_passes = 2;
-		c->p.n.min_improvement_to_continue = 32;
-		c->p.n.min_bits_to_use_nonfinal_path = 32;
-		c->p.n.max_len_to_optimize_static_block = 0;
-		deflate_init_offset_slot_full(c);
-		break;
-	case 11:
-		c->impl = deflate_compress_near_optimal;
-		c->max_search_depth = 100;
-		c->nice_match_length = 150;
-		c->p.n.max_optim_passes = 4;
-		c->p.n.min_improvement_to_continue = 16;
-		c->p.n.min_bits_to_use_nonfinal_path = 16;
-		c->p.n.max_len_to_optimize_static_block = 1000;
-		deflate_init_offset_slot_full(c);
-		break;
-	case 12:
-	default:
-		c->impl = deflate_compress_near_optimal;
-		c->max_search_depth = 300;
-		c->nice_match_length = DEFLATE_MAX_MATCH_LEN;
-		c->p.n.max_optim_passes = 10;
-		c->p.n.min_improvement_to_continue = 1;
-		c->p.n.min_bits_to_use_nonfinal_path = 1;
-		c->p.n.max_len_to_optimize_static_block = 10000;
-		deflate_init_offset_slot_full(c);
-		break;
-#endif /* SUPPORT_NEAR_OPTIMAL_PARSING */
-	}
-
-	deflate_init_static_codes(c);
-
-	return c;
-}
-
-
-LIBDEFLATEAPI struct libdeflate_compressor *
-libdeflate_alloc_compressor(int compression_level)
-{
-	static const struct libdeflate_options defaults = {
-		.sizeof_options = sizeof(defaults),
-	};
-	return libdeflate_alloc_compressor_ex(compression_level, &defaults);
-}
-
-LIBDEFLATEAPI size_t
-libdeflate_deflate_compress(struct libdeflate_compressor *c,
-			    const void *in, size_t in_nbytes,
-			    void *out, size_t out_nbytes_avail)
-{
-	struct deflate_output_bitstream os;
-
-	/*
-	 * For extremely short inputs, or for compression level 0, just output
-	 * uncompressed blocks.
-	 */
-	if (unlikely(in_nbytes <= c->max_passthrough_size))
-		return deflate_compress_none(in, in_nbytes,
-					     out, out_nbytes_avail);
-
-	/* Initialize the output bitstream structure. */
-	os.bitbuf = 0;
-	os.bitcount = 0;
-	os.next = out;
-	os.end = os.next + out_nbytes_avail;
-	os.overflow = false;
-
-	/* Call the actual compression function. */
-	(*c->impl)(c, in, in_nbytes, &os);
-
-	/* Return 0 if the output buffer is too small. */
-	if (os.overflow)
-		return 0;
-
-	/*
-	 * Write the final byte if needed.  This can't overflow the output
-	 * buffer because deflate_flush_block() would have set the overflow flag
-	 * if there wasn't enough space remaining for the full final block.
-	 */
-	ASSERT(os.bitcount <= 7);
-	if (os.bitcount) {
-		ASSERT(os.next < os.end);
-		*os.next++ = os.bitbuf;
-	}
-
-	/* Return the compressed size in bytes. */
-	return os.next - (u8 *)out;
-}
-
-LIBDEFLATEAPI void
-libdeflate_free_compressor(struct libdeflate_compressor *c)
-{
-	if (c)
-		libdeflate_aligned_free(c->free_func, c);
-}
-
-unsigned int
-libdeflate_get_compression_level(struct libdeflate_compressor *c)
-{
-	return c->compression_level;
-}
-
-LIBDEFLATEAPI size_t
-libdeflate_deflate_compress_bound(struct libdeflate_compressor *c,
-				  size_t in_nbytes)
-{
-	size_t max_blocks;
-
-	/*
-	 * Since the compressor never uses a compressed block when an
-	 * uncompressed block is cheaper, the worst case can be no worse than
-	 * the case where only uncompressed blocks are used.
-	 *
-	 * This is true even though up to 7 bits are "wasted" to byte-align the
-	 * bitstream when a compressed block is followed by an uncompressed
-	 * block.  This is because a compressed block wouldn't have been used if
-	 * it wasn't cheaper than an uncompressed block, and uncompressed blocks
-	 * always end on a byte boundary.  So the alignment bits will, at worst,
-	 * go up to the place where the uncompressed block would have ended.
-	 */
-
-	/*
-	 * Calculate the maximum number of uncompressed blocks that the
-	 * compressor can use for 'in_nbytes' of data.
-	 *
-	 * The minimum length that is passed to deflate_flush_block() is
-	 * MIN_BLOCK_LENGTH bytes, except for the final block if needed.  If
-	 * deflate_flush_block() decides to use an uncompressed block, it
-	 * actually will (in general) output a series of uncompressed blocks in
-	 * order to stay within the UINT16_MAX limit of DEFLATE.  But this can
-	 * be disregarded here as long as '2 * MIN_BLOCK_LENGTH <= UINT16_MAX',
-	 * as in that case this behavior can't result in more blocks than the
-	 * case where deflate_flush_block() is called with min-length inputs.
-	 *
-	 * So the number of uncompressed blocks needed would be bounded by
-	 * DIV_ROUND_UP(in_nbytes, MIN_BLOCK_LENGTH).  However, empty inputs
-	 * need 1 (empty) block, which gives the final expression below.
-	 */
-	STATIC_ASSERT(2 * MIN_BLOCK_LENGTH <= UINT16_MAX);
-	max_blocks = MAX(DIV_ROUND_UP(in_nbytes, MIN_BLOCK_LENGTH), 1);
-
-	/*
-	 * Each uncompressed block has 5 bytes of overhead, for the BFINAL,
-	 * BTYPE, LEN, and NLEN fields.  (For the reason explained earlier, the
-	 * alignment bits at the very start of the block can be disregarded;
-	 * they would otherwise increase the overhead to 6 bytes per block.)
-	 * Therefore, the maximum number of overhead bytes is '5 * max_blocks'.
-	 * To get the final bound, add the number of uncompressed bytes.
-	 */
-	return (5 * max_blocks) + in_nbytes;
-}
diff --git a/vendor/core/vendor/libdeflate/lib/deflate_compress.h b/vendor/core/vendor/libdeflate/lib/deflate_compress.h
deleted file mode 100644
index 9451d548..00000000
--- a/vendor/core/vendor/libdeflate/lib/deflate_compress.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef LIB_DEFLATE_COMPRESS_H
-#define LIB_DEFLATE_COMPRESS_H
-
-#include "lib_common.h"
-
-/*
- * DEFLATE compression is private to deflate_compress.c, but we do need to be
- * able to query the compression level for zlib and gzip header generation.
- */
-
-struct libdeflate_compressor;
-
-unsigned int libdeflate_get_compression_level(struct libdeflate_compressor *c);
-
-#endif /* LIB_DEFLATE_COMPRESS_H */
diff --git a/vendor/core/vendor/libdeflate/lib/deflate_constants.h b/vendor/core/vendor/libdeflate/lib/deflate_constants.h
deleted file mode 100644
index 95c9e0a5..00000000
--- a/vendor/core/vendor/libdeflate/lib/deflate_constants.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * deflate_constants.h - constants for the DEFLATE compression format
- */
-
-#ifndef LIB_DEFLATE_CONSTANTS_H
-#define LIB_DEFLATE_CONSTANTS_H
-
-/* Valid block types  */
-#define DEFLATE_BLOCKTYPE_UNCOMPRESSED		0
-#define DEFLATE_BLOCKTYPE_STATIC_HUFFMAN	1
-#define DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN	2
-
-/* Minimum and maximum supported match lengths (in bytes)  */
-#define DEFLATE_MIN_MATCH_LEN			3
-#define DEFLATE_MAX_MATCH_LEN			258
-
-/* Maximum supported match offset (in bytes) */
-#define DEFLATE_MAX_MATCH_OFFSET		32768
-
-/* log2 of DEFLATE_MAX_MATCH_OFFSET */
-#define DEFLATE_WINDOW_ORDER			15
-
-/* Number of symbols in each Huffman code.  Note: for the literal/length
- * and offset codes, these are actually the maximum values; a given block
- * might use fewer symbols.  */
-#define DEFLATE_NUM_PRECODE_SYMS		19
-#define DEFLATE_NUM_LITLEN_SYMS			288
-#define DEFLATE_NUM_OFFSET_SYMS			32
-
-/* The maximum number of symbols across all codes  */
-#define DEFLATE_MAX_NUM_SYMS			288
-
-/* Division of symbols in the literal/length code  */
-#define DEFLATE_NUM_LITERALS			256
-#define DEFLATE_END_OF_BLOCK			256
-#define DEFLATE_FIRST_LEN_SYM			257
-
-/* Maximum codeword length, in bits, within each Huffman code  */
-#define DEFLATE_MAX_PRE_CODEWORD_LEN		7
-#define DEFLATE_MAX_LITLEN_CODEWORD_LEN		15
-#define DEFLATE_MAX_OFFSET_CODEWORD_LEN		15
-
-/* The maximum codeword length across all codes  */
-#define DEFLATE_MAX_CODEWORD_LEN		15
-
-/* Maximum possible overrun when decoding codeword lengths  */
-#define DEFLATE_MAX_LENS_OVERRUN		137
-
-/*
- * Maximum number of extra bits that may be required to represent a match
- * length or offset.
- */
-#define DEFLATE_MAX_EXTRA_LENGTH_BITS		5
-#define DEFLATE_MAX_EXTRA_OFFSET_BITS		13
-
-#endif /* LIB_DEFLATE_CONSTANTS_H */
diff --git a/vendor/core/vendor/libdeflate/lib/deflate_decompress.c b/vendor/core/vendor/libdeflate/lib/deflate_decompress.c
deleted file mode 100644
index d5af5eb0..00000000
--- a/vendor/core/vendor/libdeflate/lib/deflate_decompress.c
+++ /dev/null
@@ -1,1208 +0,0 @@
-/*
- * deflate_decompress.c - a decompressor for DEFLATE
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- *
- * ---------------------------------------------------------------------------
- *
- * This is a highly optimized DEFLATE decompressor.  It is much faster than
- * vanilla zlib, typically well over twice as fast, though results vary by CPU.
- *
- * Why this is faster than vanilla zlib:
- *
- * - Word accesses rather than byte accesses when reading input
- * - Word accesses rather than byte accesses when copying matches
- * - Faster Huffman decoding combined with various DEFLATE-specific tricks
- * - Larger bitbuffer variable that doesn't need to be refilled as often
- * - Other optimizations to remove unnecessary branches
- * - Only full-buffer decompression is supported, so the code doesn't need to
- *   support stopping and resuming decompression.
- * - On x86_64, a version of the decompression routine is compiled with BMI2
- *   instructions enabled and is used automatically at runtime when supported.
- */
-
-#include "lib_common.h"
-#include "deflate_constants.h"
-
-/*
- * If the expression passed to SAFETY_CHECK() evaluates to false, then the
- * decompression routine immediately returns LIBDEFLATE_BAD_DATA, indicating the
- * compressed data is invalid.
- *
- * Theoretically, these checks could be disabled for specialized applications
- * where all input to the decompressor will be trusted.
- */
-#if 0
-#  pragma message("UNSAFE DECOMPRESSION IS ENABLED. THIS MUST ONLY BE USED IF THE DECOMPRESSOR INPUT WILL ALWAYS BE TRUSTED!")
-#  define SAFETY_CHECK(expr)	(void)(expr)
-#else
-#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
-#endif
-
-/*****************************************************************************
- *				Input bitstream                              *
- *****************************************************************************/
-
-/*
- * The state of the "input bitstream" consists of the following variables:
- *
- *	- in_next: a pointer to the next unread byte in the input buffer
- *
- *	- in_end: a pointer to just past the end of the input buffer
- *
- *	- bitbuf: a word-sized variable containing bits that have been read from
- *		  the input buffer or from the implicit appended zero bytes
- *
- *	- bitsleft: the number of bits in 'bitbuf' available to be consumed.
- *		    After REFILL_BITS_BRANCHLESS(), 'bitbuf' can actually
- *		    contain more bits than this.  However, only the bits counted
- *		    by 'bitsleft' can actually be consumed; the rest can only be
- *		    used for preloading.
- *
- *		    As a micro-optimization, we allow bits 8 and higher of
- *		    'bitsleft' to contain garbage.  When consuming the bits
- *		    associated with a decode table entry, this allows us to do
- *		    'bitsleft -= entry' instead of 'bitsleft -= (u8)entry'.
- *		    On some CPUs, this helps reduce instruction dependencies.
- *		    This does have the disadvantage that 'bitsleft' sometimes
- *		    needs to be cast to 'u8', such as when it's used as a shift
- *		    amount in REFILL_BITS_BRANCHLESS().  But that one happens
- *		    for free since most CPUs ignore high bits in shift amounts.
- *
- *	- overread_count: the total number of implicit appended zero bytes that
- *			  have been loaded into the bitbuffer, including any
- *			  counted by 'bitsleft' and any already consumed
- */
-
-/*
- * The type for the bitbuffer variable ('bitbuf' described above).  For best
- * performance, this should have size equal to a machine word.
- *
- * 64-bit platforms have a significant advantage: they get a bigger bitbuffer
- * which they don't have to refill as often.
- */
-typedef machine_word_t bitbuf_t;
-#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
-
-/* BITMASK(n) returns a bitmask of length 'n'. */
-#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
-
-/*
- * MAX_BITSLEFT is the maximum number of consumable bits, i.e. the maximum value
- * of '(u8)bitsleft'.  This is the size of the bitbuffer variable, minus 1 if
- * the branchless refill method is being used (see REFILL_BITS_BRANCHLESS()).
- */
-#define MAX_BITSLEFT	\
-	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
-
-/*
- * CONSUMABLE_NBITS is the minimum number of bits that are guaranteed to be
- * consumable (counted in 'bitsleft') immediately after refilling the bitbuffer.
- * Since only whole bytes can be added to 'bitsleft', the worst case is
- * 'MAX_BITSLEFT - 7': the smallest amount where another byte doesn't fit.
- */
-#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
-
-/*
- * FASTLOOP_PRELOADABLE_NBITS is the minimum number of bits that are guaranteed
- * to be preloadable immediately after REFILL_BITS_IN_FASTLOOP().  (It is *not*
- * guaranteed after REFILL_BITS(), since REFILL_BITS() falls back to a
- * byte-at-a-time refill method near the end of input.)  This may exceed the
- * number of consumable bits (counted by 'bitsleft').  Any bits not counted in
- * 'bitsleft' can only be used for precomputation and cannot be consumed.
- */
-#define FASTLOOP_PRELOADABLE_NBITS	\
-	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
-
-/*
- * PRELOAD_SLACK is the minimum number of bits that are guaranteed to be
- * preloadable but not consumable, following REFILL_BITS_IN_FASTLOOP() and any
- * subsequent consumptions.  This is 1 bit if the branchless refill method is
- * being used, and 0 bits otherwise.
- */
-#define PRELOAD_SLACK	MAX(0, FASTLOOP_PRELOADABLE_NBITS - MAX_BITSLEFT)
-
-/*
- * CAN_CONSUME(n) is true if it's guaranteed that if the bitbuffer has just been
- * refilled, then it's always possible to consume 'n' bits from it.  'n' should
- * be a compile-time constant, to enable compile-time evaluation.
- */
-#define CAN_CONSUME(n)	(CONSUMABLE_NBITS >= (n))
-
-/*
- * CAN_CONSUME_AND_THEN_PRELOAD(consume_nbits, preload_nbits) is true if it's
- * guaranteed that after REFILL_BITS_IN_FASTLOOP(), it's always possible to
- * consume 'consume_nbits' bits, then preload 'preload_nbits' bits.  The
- * arguments should be compile-time constants to enable compile-time evaluation.
- */
-#define CAN_CONSUME_AND_THEN_PRELOAD(consume_nbits, preload_nbits)	\
-	(CONSUMABLE_NBITS >= (consume_nbits) &&				\
-	 FASTLOOP_PRELOADABLE_NBITS >= (consume_nbits) + (preload_nbits))
-
-/*
- * REFILL_BITS_BRANCHLESS() branchlessly refills the bitbuffer variable by
- * reading the next word from the input buffer and updating 'in_next' and
- * 'bitsleft' based on how many bits were refilled -- counting whole bytes only.
- * This is much faster than reading a byte at a time, at least if the CPU is
- * little endian and supports fast unaligned memory accesses.
- *
- * The simplest way of branchlessly updating 'bitsleft' would be:
- *
- *	bitsleft += (MAX_BITSLEFT - bitsleft) & ~7;
- *
- * To make it faster, we define MAX_BITSLEFT to be 'WORDBITS - 1' rather than
- * WORDBITS, so that in binary it looks like 111111 or 11111.  Then, we update
- * 'bitsleft' by just setting the bits above the low 3 bits:
- *
- *	bitsleft |= MAX_BITSLEFT & ~7;
- *
- * That compiles down to a single instruction like 'or $0x38, %rbp'.  Using
- * 'MAX_BITSLEFT == WORDBITS - 1' also has the advantage that refills can be
- * done when 'bitsleft == MAX_BITSLEFT' without invoking undefined behavior.
- *
- * The simplest way of branchlessly updating 'in_next' would be:
- *
- *	in_next += (MAX_BITSLEFT - bitsleft) >> 3;
- *
- * With 'MAX_BITSLEFT == WORDBITS - 1' we could use an XOR instead, though this
- * isn't really better:
- *
- *	in_next += (MAX_BITSLEFT ^ bitsleft) >> 3;
- *
- * An alternative which can be marginally better is the following:
- *
- *	in_next += sizeof(bitbuf_t) - 1;
- *	in_next -= (bitsleft >> 3) & 0x7;
- *
- * It seems this would increase the number of CPU instructions from 3 (sub, shr,
- * add) to 4 (add, shr, and, sub).  However, if the CPU has a bitfield
- * extraction instruction (e.g. arm's ubfx), it stays at 3, and is potentially
- * more efficient because the length of the longest dependency chain decreases
- * from 3 to 2.  This alternative also has the advantage that it ignores the
- * high bits in 'bitsleft', so it is compatible with the micro-optimization we
- * use where we let the high bits of 'bitsleft' contain garbage.
- */
-#define REFILL_BITS_BRANCHLESS()					\
-do {									\
-	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
-	in_next += sizeof(bitbuf_t) - 1;				\
-	in_next -= (bitsleft >> 3) & 0x7;				\
-	bitsleft |= MAX_BITSLEFT & ~7;					\
-} while (0)
-
-/*
- * REFILL_BITS() loads bits from the input buffer until the bitbuffer variable
- * contains at least CONSUMABLE_NBITS consumable bits.
- *
- * This checks for the end of input, and it doesn't guarantee
- * FASTLOOP_PRELOADABLE_NBITS, so it can't be used in the fastloop.
- *
- * If we would overread the input buffer, we just don't read anything, leaving
- * the bits zeroed but marking them filled.  This simplifies the decompressor
- * because it removes the need to always be able to distinguish between real
- * overreads and overreads caused only by the decompressor's own lookahead.
- *
- * We do still keep track of the number of bytes that have been overread, for
- * two reasons.  First, it allows us to determine the exact number of bytes that
- * were consumed once the stream ends or an uncompressed block is reached.
- * Second, it allows us to stop early if the overread amount gets so large (more
- * than sizeof bitbuf) that it can only be caused by a real overread.  (The
- * second part is arguably unneeded, since libdeflate is buffer-based; given
- * infinite zeroes, it will eventually either completely fill the output buffer
- * or return an error.  However, we do it to be slightly more friendly to the
- * not-recommended use case of decompressing with an unknown output size.)
- */
-#define REFILL_BITS()							\
-do {									\
-	if (UNALIGNED_ACCESS_IS_FAST &&					\
-	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
-		REFILL_BITS_BRANCHLESS();				\
-	} else {							\
-		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
-			if (likely(in_next != in_end)) {		\
-				bitbuf |= (bitbuf_t)*in_next++ <<	\
-					  (u8)bitsleft;			\
-			} else {					\
-				overread_count++;			\
-				SAFETY_CHECK(overread_count <=		\
-					     sizeof(bitbuf_t));		\
-			}						\
-			bitsleft += 8;					\
-		}							\
-	}								\
-} while (0)
-
-/*
- * REFILL_BITS_IN_FASTLOOP() is like REFILL_BITS(), but it doesn't check for the
- * end of the input.  It can only be used in the fastloop.
- */
-#define REFILL_BITS_IN_FASTLOOP()					\
-do {									\
-	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
-		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
-	if (UNALIGNED_ACCESS_IS_FAST) {					\
-		REFILL_BITS_BRANCHLESS();				\
-	} else {							\
-		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
-			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
-			bitsleft += 8;					\
-		}							\
-	}								\
-} while (0)
-
-/*
- * This is the worst-case maximum number of output bytes that are written to
- * during each iteration of the fastloop.  The worst case is 2 literals, then a
- * match of length DEFLATE_MAX_MATCH_LEN.  Additionally, some slack space must
- * be included for the intentional overrun in the match copy implementation.
- */
-#define FASTLOOP_MAX_BYTES_WRITTEN	\
-	(2 + DEFLATE_MAX_MATCH_LEN + (5 * WORDBYTES) - 1)
-
-/*
- * This is the worst-case maximum number of input bytes that are read during
- * each iteration of the fastloop.  To get this value, we first compute the
- * greatest number of bits that can be refilled during a loop iteration.  The
- * refill at the beginning can add at most MAX_BITSLEFT, and the amount that can
- * be refilled later is no more than the maximum amount that can be consumed by
- * 2 literals that don't need a subtable, then a match.  We convert this value
- * to bytes, rounding up; this gives the maximum number of bytes that 'in_next'
- * can be advanced.  Finally, we add sizeof(bitbuf_t) to account for
- * REFILL_BITS_BRANCHLESS() reading a word past 'in_next'.
- */
-#define FASTLOOP_MAX_BYTES_READ					\
-	(DIV_ROUND_UP(MAX_BITSLEFT + (2 * LITLEN_TABLEBITS) +	\
-		      LENGTH_MAXBITS + OFFSET_MAXBITS, 8) +	\
-	 sizeof(bitbuf_t))
-
-/*****************************************************************************
- *                              Huffman decoding                             *
- *****************************************************************************/
-
-/*
- * The fastest way to decode Huffman-encoded data is basically to use a decode
- * table that maps the next TABLEBITS bits of data to their symbol.  Each entry
- * decode_table[i] maps to the symbol whose codeword is a prefix of 'i'.  A
- * symbol with codeword length 'n' has '2**(TABLEBITS-n)' entries in the table.
- *
- * Ideally, TABLEBITS and the maximum codeword length would be the same; some
- * compression formats are designed with this goal in mind.  Unfortunately, in
- * DEFLATE, the maximum litlen and offset codeword lengths are 15 bits, which is
- * too large for a practical TABLEBITS.  It's not *that* much larger, though, so
- * the workaround is to use a single level of subtables.  In the main table,
- * entries for prefixes of codewords longer than TABLEBITS contain a "pointer"
- * to the appropriate subtable along with the number of bits it is indexed with.
- *
- * The most efficient way to allocate subtables is to allocate them dynamically
- * after the main table.  The worst-case number of table entries needed,
- * including subtables, is precomputable; see the ENOUGH constants below.
- *
- * A useful optimization is to store the codeword lengths in the decode table so
- * that they don't have to be looked up by indexing a separate table that maps
- * symbols to their codeword lengths.  We basically do this; however, for the
- * litlen and offset codes we also implement some DEFLATE-specific optimizations
- * that build in the consideration of the "extra bits" and the
- * literal/length/end-of-block division.  For the exact decode table entry
- * format we use, see the definitions of the *_decode_results[] arrays below.
- */
-
-
-/*
- * These are the TABLEBITS values we use for each of the DEFLATE Huffman codes,
- * along with their corresponding ENOUGH values.
- *
- * For the precode, we use PRECODE_TABLEBITS == 7 since this is the maximum
- * precode codeword length.  This avoids ever needing subtables.
- *
- * For the litlen and offset codes, we cannot realistically avoid ever needing
- * subtables, since litlen and offset codewords can be up to 15 bits.  A higher
- * TABLEBITS reduces the number of lookups that need a subtable, which increases
- * performance; however, it increases memory usage and makes building the table
- * take longer, which decreases performance.  We choose values that work well in
- * practice, making subtables rarely needed without making the tables too large.
- *
- * Our choice of OFFSET_TABLEBITS == 8 is a bit low; without any special
- * considerations, 9 would fit the trade-off curve better.  However, there is a
- * performance benefit to using exactly 8 bits when it is a compile-time
- * constant, as many CPUs can take the low byte more easily than the low 9 bits.
- *
- * zlib treats its equivalents of TABLEBITS as maximum values; whenever it
- * builds a table, it caps the actual table_bits to the longest codeword.  This
- * makes sense in theory, as there's no need for the table to be any larger than
- * needed to support the longest codeword.  However, having the table bits be a
- * compile-time constant is beneficial to the performance of the decode loop, so
- * there is a trade-off.  libdeflate currently uses the dynamic table_bits
- * strategy for the litlen table only, due to its larger maximum size.
- * PRECODE_TABLEBITS and OFFSET_TABLEBITS are smaller, so going dynamic there
- * isn't as useful, and OFFSET_TABLEBITS=8 is useful as mentioned above.
- *
- * Each TABLEBITS value has a corresponding ENOUGH value that gives the
- * worst-case maximum number of decode table entries, including the main table
- * and all subtables.  The ENOUGH value depends on three parameters:
- *
- *	(1) the maximum number of symbols in the code (DEFLATE_NUM_*_SYMS)
- *	(2) the maximum number of main table bits (*_TABLEBITS)
- *	(3) the maximum allowed codeword length (DEFLATE_MAX_*_CODEWORD_LEN)
- *
- * The ENOUGH values were computed using the utility program 'enough' from zlib.
- */
-#define PRECODE_TABLEBITS	7
-#define PRECODE_ENOUGH		128	/* enough 19 7 7	*/
-#define LITLEN_TABLEBITS	11
-#define LITLEN_ENOUGH		2342	/* enough 288 11 15	*/
-#define OFFSET_TABLEBITS	8
-#define OFFSET_ENOUGH		402	/* enough 32 8 15	*/
-
-/*
- * make_decode_table_entry() creates a decode table entry for the given symbol
- * by combining the static part 'decode_results[sym]' with the dynamic part
- * 'len', which is the remaining codeword length (the codeword length for main
- * table entries, or the codeword length minus TABLEBITS for subtable entries).
- *
- * In all cases, we add 'len' to each of the two low-order bytes to create the
- * appropriately-formatted decode table entry.  See the definitions of the
- * *_decode_results[] arrays below, where the entry format is described.
- */
-static forceinline u32
-make_decode_table_entry(const u32 decode_results[], u32 sym, u32 len)
-{
-	return decode_results[sym] + (len << 8) + len;
-}
-
-/*
- * Here is the format of our precode decode table entries.  Bits not explicitly
- * described contain zeroes:
- *
- *	Bit 20-16:  presym
- *	Bit 10-8:   codeword length [not used]
- *	Bit 2-0:    codeword length
- *
- * The precode decode table never has subtables, since we use
- * PRECODE_TABLEBITS == DEFLATE_MAX_PRE_CODEWORD_LEN.
- *
- * precode_decode_results[] contains the static part of the entry for each
- * symbol.  make_decode_table_entry() produces the final entries.
- */
-static const u32 precode_decode_results[] = {
-#define ENTRY(presym)	((u32)presym << 16)
-	ENTRY(0)   , ENTRY(1)   , ENTRY(2)   , ENTRY(3)   ,
-	ENTRY(4)   , ENTRY(5)   , ENTRY(6)   , ENTRY(7)   ,
-	ENTRY(8)   , ENTRY(9)   , ENTRY(10)  , ENTRY(11)  ,
-	ENTRY(12)  , ENTRY(13)  , ENTRY(14)  , ENTRY(15)  ,
-	ENTRY(16)  , ENTRY(17)  , ENTRY(18)  ,
-#undef ENTRY
-};
-
-/* Litlen and offset decode table entry flags */
-
-/* Indicates a literal entry in the litlen decode table */
-#define HUFFDEC_LITERAL			0x80000000
-
-/* Indicates that HUFFDEC_SUBTABLE_POINTER or HUFFDEC_END_OF_BLOCK is set */
-#define HUFFDEC_EXCEPTIONAL		0x00008000
-
-/* Indicates a subtable pointer entry in the litlen or offset decode table */
-#define HUFFDEC_SUBTABLE_POINTER	0x00004000
-
-/* Indicates an end-of-block entry in the litlen decode table */
-#define HUFFDEC_END_OF_BLOCK		0x00002000
-
-/* Maximum number of bits that can be consumed by decoding a match length */
-#define LENGTH_MAXBITS		(DEFLATE_MAX_LITLEN_CODEWORD_LEN + \
-				 DEFLATE_MAX_EXTRA_LENGTH_BITS)
-#define LENGTH_MAXFASTBITS	(LITLEN_TABLEBITS /* no subtable needed */ + \
-				 DEFLATE_MAX_EXTRA_LENGTH_BITS)
-
-/*
- * Here is the format of our litlen decode table entries.  Bits not explicitly
- * described contain zeroes:
- *
- *	Literals:
- *		Bit 31:     1 (HUFFDEC_LITERAL)
- *		Bit 23-16:  literal value
- *		Bit 15:     0 (!HUFFDEC_EXCEPTIONAL)
- *		Bit 14:     0 (!HUFFDEC_SUBTABLE_POINTER)
- *		Bit 13:     0 (!HUFFDEC_END_OF_BLOCK)
- *		Bit 11-8:   remaining codeword length [not used]
- *		Bit 3-0:    remaining codeword length
- *	Lengths:
- *		Bit 31:     0 (!HUFFDEC_LITERAL)
- *		Bit 24-16:  length base value
- *		Bit 15:     0 (!HUFFDEC_EXCEPTIONAL)
- *		Bit 14:     0 (!HUFFDEC_SUBTABLE_POINTER)
- *		Bit 13:     0 (!HUFFDEC_END_OF_BLOCK)
- *		Bit 11-8:   remaining codeword length
- *		Bit 4-0:    remaining codeword length + number of extra bits
- *	End of block:
- *		Bit 31:     0 (!HUFFDEC_LITERAL)
- *		Bit 15:     1 (HUFFDEC_EXCEPTIONAL)
- *		Bit 14:     0 (!HUFFDEC_SUBTABLE_POINTER)
- *		Bit 13:     1 (HUFFDEC_END_OF_BLOCK)
- *		Bit 11-8:   remaining codeword length [not used]
- *		Bit 3-0:    remaining codeword length
- *	Subtable pointer:
- *		Bit 31:     0 (!HUFFDEC_LITERAL)
- *		Bit 30-16:  index of start of subtable
- *		Bit 15:     1 (HUFFDEC_EXCEPTIONAL)
- *		Bit 14:     1 (HUFFDEC_SUBTABLE_POINTER)
- *		Bit 13:     0 (!HUFFDEC_END_OF_BLOCK)
- *		Bit 11-8:   number of subtable bits
- *		Bit 3-0:    number of main table bits
- *
- * This format has several desirable properties:
- *
- *	- The codeword length, length slot base, and number of extra length bits
- *	  are all built in.  This eliminates the need to separately look up this
- *	  information by indexing separate arrays by symbol or length slot.
- *
- *	- The HUFFDEC_* flags enable easily distinguishing between the different
- *	  types of entries.  The HUFFDEC_LITERAL flag enables a fast path for
- *	  literals; the high bit is used for this, as some CPUs can test the
- *	  high bit more easily than other bits.  The HUFFDEC_EXCEPTIONAL flag
- *	  makes it possible to detect the two unlikely cases (subtable pointer
- *	  and end of block) in a single bit flag test.
- *
- *	- The low byte is the number of bits that need to be removed from the
- *	  bitstream; this makes this value easily accessible, and it enables the
- *	  micro-optimization of doing 'bitsleft -= entry' instead of
- *	  'bitsleft -= (u8)entry'.  It also includes the number of extra bits,
- *	  so they don't need to be removed separately.
- *
- *	- The flags in bits 15-13 are arranged to be 0 when the
- *	  "remaining codeword length" in bits 11-8 is needed, making this value
- *	  fairly easily accessible as well via a shift and downcast.
- *
- *	- Similarly, bits 13-12 are 0 when the "subtable bits" in bits 11-8 are
- *	  needed, making it possible to extract this value with '& 0x3F' rather
- *	  than '& 0xF'.  This value is only used as a shift amount, so this can
- *	  save an 'and' instruction as the masking by 0x3F happens implicitly.
- *
- * litlen_decode_results[] contains the static part of the entry for each
- * symbol.  make_decode_table_entry() produces the final entries.
- */
-static const u32 litlen_decode_results[] = {
-
-	/* Literals */
-#define ENTRY(literal)	(HUFFDEC_LITERAL | ((u32)literal << 16))
-	ENTRY(0)   , ENTRY(1)   , ENTRY(2)   , ENTRY(3)   ,
-	ENTRY(4)   , ENTRY(5)   , ENTRY(6)   , ENTRY(7)   ,
-	ENTRY(8)   , ENTRY(9)   , ENTRY(10)  , ENTRY(11)  ,
-	ENTRY(12)  , ENTRY(13)  , ENTRY(14)  , ENTRY(15)  ,
-	ENTRY(16)  , ENTRY(17)  , ENTRY(18)  , ENTRY(19)  ,
-	ENTRY(20)  , ENTRY(21)  , ENTRY(22)  , ENTRY(23)  ,
-	ENTRY(24)  , ENTRY(25)  , ENTRY(26)  , ENTRY(27)  ,
-	ENTRY(28)  , ENTRY(29)  , ENTRY(30)  , ENTRY(31)  ,
-	ENTRY(32)  , ENTRY(33)  , ENTRY(34)  , ENTRY(35)  ,
-	ENTRY(36)  , ENTRY(37)  , ENTRY(38)  , ENTRY(39)  ,
-	ENTRY(40)  , ENTRY(41)  , ENTRY(42)  , ENTRY(43)  ,
-	ENTRY(44)  , ENTRY(45)  , ENTRY(46)  , ENTRY(47)  ,
-	ENTRY(48)  , ENTRY(49)  , ENTRY(50)  , ENTRY(51)  ,
-	ENTRY(52)  , ENTRY(53)  , ENTRY(54)  , ENTRY(55)  ,
-	ENTRY(56)  , ENTRY(57)  , ENTRY(58)  , ENTRY(59)  ,
-	ENTRY(60)  , ENTRY(61)  , ENTRY(62)  , ENTRY(63)  ,
-	ENTRY(64)  , ENTRY(65)  , ENTRY(66)  , ENTRY(67)  ,
-	ENTRY(68)  , ENTRY(69)  , ENTRY(70)  , ENTRY(71)  ,
-	ENTRY(72)  , ENTRY(73)  , ENTRY(74)  , ENTRY(75)  ,
-	ENTRY(76)  , ENTRY(77)  , ENTRY(78)  , ENTRY(79)  ,
-	ENTRY(80)  , ENTRY(81)  , ENTRY(82)  , ENTRY(83)  ,
-	ENTRY(84)  , ENTRY(85)  , ENTRY(86)  , ENTRY(87)  ,
-	ENTRY(88)  , ENTRY(89)  , ENTRY(90)  , ENTRY(91)  ,
-	ENTRY(92)  , ENTRY(93)  , ENTRY(94)  , ENTRY(95)  ,
-	ENTRY(96)  , ENTRY(97)  , ENTRY(98)  , ENTRY(99)  ,
-	ENTRY(100) , ENTRY(101) , ENTRY(102) , ENTRY(103) ,
-	ENTRY(104) , ENTRY(105) , ENTRY(106) , ENTRY(107) ,
-	ENTRY(108) , ENTRY(109) , ENTRY(110) , ENTRY(111) ,
-	ENTRY(112) , ENTRY(113) , ENTRY(114) , ENTRY(115) ,
-	ENTRY(116) , ENTRY(117) , ENTRY(118) , ENTRY(119) ,
-	ENTRY(120) , ENTRY(121) , ENTRY(122) , ENTRY(123) ,
-	ENTRY(124) , ENTRY(125) , ENTRY(126) , ENTRY(127) ,
-	ENTRY(128) , ENTRY(129) , ENTRY(130) , ENTRY(131) ,
-	ENTRY(132) , ENTRY(133) , ENTRY(134) , ENTRY(135) ,
-	ENTRY(136) , ENTRY(137) , ENTRY(138) , ENTRY(139) ,
-	ENTRY(140) , ENTRY(141) , ENTRY(142) , ENTRY(143) ,
-	ENTRY(144) , ENTRY(145) , ENTRY(146) , ENTRY(147) ,
-	ENTRY(148) , ENTRY(149) , ENTRY(150) , ENTRY(151) ,
-	ENTRY(152) , ENTRY(153) , ENTRY(154) , ENTRY(155) ,
-	ENTRY(156) , ENTRY(157) , ENTRY(158) , ENTRY(159) ,
-	ENTRY(160) , ENTRY(161) , ENTRY(162) , ENTRY(163) ,
-	ENTRY(164) , ENTRY(165) , ENTRY(166) , ENTRY(167) ,
-	ENTRY(168) , ENTRY(169) , ENTRY(170) , ENTRY(171) ,
-	ENTRY(172) , ENTRY(173) , ENTRY(174) , ENTRY(175) ,
-	ENTRY(176) , ENTRY(177) , ENTRY(178) , ENTRY(179) ,
-	ENTRY(180) , ENTRY(181) , ENTRY(182) , ENTRY(183) ,
-	ENTRY(184) , ENTRY(185) , ENTRY(186) , ENTRY(187) ,
-	ENTRY(188) , ENTRY(189) , ENTRY(190) , ENTRY(191) ,
-	ENTRY(192) , ENTRY(193) , ENTRY(194) , ENTRY(195) ,
-	ENTRY(196) , ENTRY(197) , ENTRY(198) , ENTRY(199) ,
-	ENTRY(200) , ENTRY(201) , ENTRY(202) , ENTRY(203) ,
-	ENTRY(204) , ENTRY(205) , ENTRY(206) , ENTRY(207) ,
-	ENTRY(208) , ENTRY(209) , ENTRY(210) , ENTRY(211) ,
-	ENTRY(212) , ENTRY(213) , ENTRY(214) , ENTRY(215) ,
-	ENTRY(216) , ENTRY(217) , ENTRY(218) , ENTRY(219) ,
-	ENTRY(220) , ENTRY(221) , ENTRY(222) , ENTRY(223) ,
-	ENTRY(224) , ENTRY(225) , ENTRY(226) , ENTRY(227) ,
-	ENTRY(228) , ENTRY(229) , ENTRY(230) , ENTRY(231) ,
-	ENTRY(232) , ENTRY(233) , ENTRY(234) , ENTRY(235) ,
-	ENTRY(236) , ENTRY(237) , ENTRY(238) , ENTRY(239) ,
-	ENTRY(240) , ENTRY(241) , ENTRY(242) , ENTRY(243) ,
-	ENTRY(244) , ENTRY(245) , ENTRY(246) , ENTRY(247) ,
-	ENTRY(248) , ENTRY(249) , ENTRY(250) , ENTRY(251) ,
-	ENTRY(252) , ENTRY(253) , ENTRY(254) , ENTRY(255) ,
-#undef ENTRY
-
-	/* End of block */
-	HUFFDEC_EXCEPTIONAL | HUFFDEC_END_OF_BLOCK,
-
-	/* Lengths */
-#define ENTRY(length_base, num_extra_bits)	\
-	(((u32)(length_base) << 16) | (num_extra_bits))
-	ENTRY(3  , 0) , ENTRY(4  , 0) , ENTRY(5  , 0) , ENTRY(6  , 0),
-	ENTRY(7  , 0) , ENTRY(8  , 0) , ENTRY(9  , 0) , ENTRY(10 , 0),
-	ENTRY(11 , 1) , ENTRY(13 , 1) , ENTRY(15 , 1) , ENTRY(17 , 1),
-	ENTRY(19 , 2) , ENTRY(23 , 2) , ENTRY(27 , 2) , ENTRY(31 , 2),
-	ENTRY(35 , 3) , ENTRY(43 , 3) , ENTRY(51 , 3) , ENTRY(59 , 3),
-	ENTRY(67 , 4) , ENTRY(83 , 4) , ENTRY(99 , 4) , ENTRY(115, 4),
-	ENTRY(131, 5) , ENTRY(163, 5) , ENTRY(195, 5) , ENTRY(227, 5),
-	ENTRY(258, 0) , ENTRY(258, 0) , ENTRY(258, 0) ,
-#undef ENTRY
-};
-
-/* Maximum number of bits that can be consumed by decoding a match offset */
-#define OFFSET_MAXBITS		(DEFLATE_MAX_OFFSET_CODEWORD_LEN + \
-				 DEFLATE_MAX_EXTRA_OFFSET_BITS)
-#define OFFSET_MAXFASTBITS	(OFFSET_TABLEBITS /* no subtable needed */ + \
-				 DEFLATE_MAX_EXTRA_OFFSET_BITS)
-
-/*
- * Here is the format of our offset decode table entries.  Bits not explicitly
- * described contain zeroes:
- *
- *	Offsets:
- *		Bit 31-16:  offset base value
- *		Bit 15:     0 (!HUFFDEC_EXCEPTIONAL)
- *		Bit 14:     0 (!HUFFDEC_SUBTABLE_POINTER)
- *		Bit 11-8:   remaining codeword length
- *		Bit 4-0:    remaining codeword length + number of extra bits
- *	Subtable pointer:
- *		Bit 31-16:  index of start of subtable
- *		Bit 15:     1 (HUFFDEC_EXCEPTIONAL)
- *		Bit 14:     1 (HUFFDEC_SUBTABLE_POINTER)
- *		Bit 11-8:   number of subtable bits
- *		Bit 3-0:    number of main table bits
- *
- * These work the same way as the length entries and subtable pointer entries in
- * the litlen decode table; see litlen_decode_results[] above.
- */
-static const u32 offset_decode_results[] = {
-#define ENTRY(offset_base, num_extra_bits)	\
-	(((u32)(offset_base) << 16) | (num_extra_bits))
-	ENTRY(1     , 0)  , ENTRY(2     , 0)  , ENTRY(3     , 0)  , ENTRY(4     , 0)  ,
-	ENTRY(5     , 1)  , ENTRY(7     , 1)  , ENTRY(9     , 2)  , ENTRY(13    , 2) ,
-	ENTRY(17    , 3)  , ENTRY(25    , 3)  , ENTRY(33    , 4)  , ENTRY(49    , 4)  ,
-	ENTRY(65    , 5)  , ENTRY(97    , 5)  , ENTRY(129   , 6)  , ENTRY(193   , 6)  ,
-	ENTRY(257   , 7)  , ENTRY(385   , 7)  , ENTRY(513   , 8)  , ENTRY(769   , 8)  ,
-	ENTRY(1025  , 9)  , ENTRY(1537  , 9)  , ENTRY(2049  , 10) , ENTRY(3073  , 10) ,
-	ENTRY(4097  , 11) , ENTRY(6145  , 11) , ENTRY(8193  , 12) , ENTRY(12289 , 12) ,
-	ENTRY(16385 , 13) , ENTRY(24577 , 13) , ENTRY(24577 , 13) , ENTRY(24577 , 13) ,
-#undef ENTRY
-};
-
-/*
- * The main DEFLATE decompressor structure.  Since libdeflate only supports
- * full-buffer decompression, this structure doesn't store the entire
- * decompression state, most of which is in stack variables.  Instead, this
- * struct just contains the decode tables and some temporary arrays used for
- * building them, as these are too large to comfortably allocate on the stack.
- *
- * Storing the decode tables in the decompressor struct also allows the decode
- * tables for the static codes to be reused whenever two static Huffman blocks
- * are decoded without an intervening dynamic block, even across streams.
- */
-struct libdeflate_decompressor {
-
-	/*
-	 * The arrays aren't all needed at the same time.  'precode_lens' and
-	 * 'precode_decode_table' are unneeded after 'lens' has been filled.
-	 * Furthermore, 'lens' need not be retained after building the litlen
-	 * and offset decode tables.  In fact, 'lens' can be in union with
-	 * 'litlen_decode_table' provided that 'offset_decode_table' is separate
-	 * and is built first.
-	 */
-
-	union {
-		u8 precode_lens[DEFLATE_NUM_PRECODE_SYMS];
-
-		struct {
-			u8 lens[DEFLATE_NUM_LITLEN_SYMS +
-				DEFLATE_NUM_OFFSET_SYMS +
-				DEFLATE_MAX_LENS_OVERRUN];
-
-			u32 precode_decode_table[PRECODE_ENOUGH];
-		} l;
-
-		u32 litlen_decode_table[LITLEN_ENOUGH];
-	} u;
-
-	u32 offset_decode_table[OFFSET_ENOUGH];
-
-	/* used only during build_decode_table() */
-	u16 sorted_syms[DEFLATE_MAX_NUM_SYMS];
-
-	bool static_codes_loaded;
-	unsigned litlen_tablebits;
-
-	/* The free() function for this struct, chosen at allocation time */
-	free_func_t free_func;
-};
-
-/*
- * Build a table for fast decoding of symbols from a Huffman code.  As input,
- * this function takes the codeword length of each symbol which may be used in
- * the code.  As output, it produces a decode table for the canonical Huffman
- * code described by the codeword lengths.  The decode table is built with the
- * assumption that it will be indexed with "bit-reversed" codewords, where the
- * low-order bit is the first bit of the codeword.  This format is used for all
- * Huffman codes in DEFLATE.
- *
- * @decode_table
- *	The array in which the decode table will be generated.  This array must
- *	have sufficient length; see the definition of the ENOUGH numbers.
- * @lens
- *	An array which provides, for each symbol, the length of the
- *	corresponding codeword in bits, or 0 if the symbol is unused.  This may
- *	alias @decode_table, since nothing is written to @decode_table until all
- *	@lens have been consumed.  All codeword lengths are assumed to be <=
- *	@max_codeword_len but are otherwise considered untrusted.  If they do
- *	not form a valid Huffman code, then the decode table is not built and
- *	%false is returned.
- * @num_syms
- *	The number of symbols in the code, including all unused symbols.
- * @decode_results
- *	An array which gives the incomplete decode result for each symbol.  The
- *	needed values in this array will be combined with codeword lengths to
- *	make the final decode table entries using make_decode_table_entry().
- * @table_bits
- *	The log base-2 of the number of main table entries to use.
- *	If @table_bits_ret != NULL, then @table_bits is treated as a maximum
- *	value and it will be decreased if a smaller table would be sufficient.
- * @max_codeword_len
- *	The maximum allowed codeword length for this Huffman code.
- *	Must be <= DEFLATE_MAX_CODEWORD_LEN.
- * @sorted_syms
- *	A temporary array of length @num_syms.
- * @table_bits_ret
- *	If non-NULL, then the dynamic table_bits is enabled, and the actual
- *	table_bits value will be returned here.
- *
- * Returns %true if successful; %false if the codeword lengths do not form a
- * valid Huffman code.
- */
-static bool
-build_decode_table(u32 decode_table[],
-		   const u8 lens[],
-		   const unsigned num_syms,
-		   const u32 decode_results[],
-		   unsigned table_bits,
-		   unsigned max_codeword_len,
-		   u16 *sorted_syms,
-		   unsigned *table_bits_ret)
-{
-	unsigned len_counts[DEFLATE_MAX_CODEWORD_LEN + 1];
-	unsigned offsets[DEFLATE_MAX_CODEWORD_LEN + 1];
-	unsigned sym;		/* current symbol */
-	unsigned codeword;	/* current codeword, bit-reversed */
-	unsigned len;		/* current codeword length in bits */
-	unsigned count;		/* num codewords remaining with this length */
-	u32 codespace_used;	/* codespace used out of '2^max_codeword_len' */
-	unsigned cur_table_end; /* end index of current table */
-	unsigned subtable_prefix; /* codeword prefix of current subtable */
-	unsigned subtable_start;  /* start index of current subtable */
-	unsigned subtable_bits;   /* log2 of current subtable length */
-
-	/* Count how many codewords have each length, including 0. */
-	for (len = 0; len <= max_codeword_len; len++)
-		len_counts[len] = 0;
-	for (sym = 0; sym < num_syms; sym++)
-		len_counts[lens[sym]]++;
-
-	/*
-	 * Determine the actual maximum codeword length that was used, and
-	 * decrease table_bits to it if allowed.
-	 */
-	while (max_codeword_len > 1 && len_counts[max_codeword_len] == 0)
-		max_codeword_len--;
-	if (table_bits_ret != NULL) {
-		table_bits = MIN(table_bits, max_codeword_len);
-		*table_bits_ret = table_bits;
-	}
-
-	/*
-	 * Sort the symbols primarily by increasing codeword length and
-	 * secondarily by increasing symbol value; or equivalently by their
-	 * codewords in lexicographic order, since a canonical code is assumed.
-	 *
-	 * For efficiency, also compute 'codespace_used' in the same pass over
-	 * 'len_counts[]' used to build 'offsets[]' for sorting.
-	 */
-
-	/* Ensure that 'codespace_used' cannot overflow. */
-	STATIC_ASSERT(sizeof(codespace_used) == 4);
-	STATIC_ASSERT(UINT32_MAX / (1U << (DEFLATE_MAX_CODEWORD_LEN - 1)) >=
-		      DEFLATE_MAX_NUM_SYMS);
-
-	offsets[0] = 0;
-	offsets[1] = len_counts[0];
-	codespace_used = 0;
-	for (len = 1; len < max_codeword_len; len++) {
-		offsets[len + 1] = offsets[len] + len_counts[len];
-		codespace_used = (codespace_used << 1) + len_counts[len];
-	}
-	codespace_used = (codespace_used << 1) + len_counts[len];
-
-	for (sym = 0; sym < num_syms; sym++)
-		sorted_syms[offsets[lens[sym]]++] = sym;
-
-	sorted_syms += offsets[0]; /* Skip unused symbols */
-
-	/* lens[] is done being used, so we can write to decode_table[] now. */
-
-	/*
-	 * Check whether the lengths form a complete code (exactly fills the
-	 * codespace), an incomplete code (doesn't fill the codespace), or an
-	 * overfull code (overflows the codespace).  A codeword of length 'n'
-	 * uses proportion '1/(2^n)' of the codespace.  An overfull code is
-	 * nonsensical, so is considered invalid.  An incomplete code is
-	 * considered valid only in two specific cases; see below.
-	 */
-
-	/* overfull code? */
-	if (unlikely(codespace_used > (1U << max_codeword_len)))
-		return false;
-
-	/* incomplete code? */
-	if (unlikely(codespace_used < (1U << max_codeword_len))) {
-		u32 entry;
-		unsigned i;
-
-		/*
-		 * The DEFLATE RFC explicitly allows the offset code to be
-		 * incomplete in two cases: a code containing just 1 codeword,
-		 * if that codeword has length 1; and a code containing no
-		 * codewords.  Note: the list of offset codeword lengths is
-		 * always nonempty, but lengths of 0 don't count as codewords.
-		 *
-		 * The RFC doesn't say whether the same cases are allowed for
-		 * the litlen and pre codes.  It's actually impossible for no
-		 * symbols to be used from these codes; however, it's
-		 * technically possible for only one symbol to be used.  zlib
-		 * allows 1 codeword for the litlen code, but not the precode.
-		 * The RFC also doesn't say whether, when there is 1 codeword,
-		 * that codeword is '0' or '1'.  zlib uses '0'.
-		 *
-		 * We accept what zlib accepts, plus a bit more.  First, we
-		 * don't treat the precode more strictly than the litlen and
-		 * offset codes.  There's no convincing reason to add a special
-		 * case for the precode here.
-		 *
-		 * Second, we just map each allowed incompete code to a complete
-		 * code with only real symbols.  To do this, we choose a symbol,
-		 * either the used symbol (for codes with 1 codeword) or an
-		 * arbitrary symbol (for empty codes), and give it both
-		 * codewords '0' and '1'.  zlib instead uses a special ERROR
-		 * symbol in the part of the codespace the code doesn't use.
-		 * However, having an ERROR symbol reduces the performance of
-		 * the Huffman decoder, for no real benefit.  Our approach also
-		 * avoids having to decide whether '0' or '1' is correct.
-		 *
-		 * Like zlib, we still reject all incomplete codes that contain
-		 * more than 1 codeword or a codeword length greater than 1.
-		 */
-		if (codespace_used == 0) {
-			sym = 0; /* arbitrary */
-		} else {
-			if (codespace_used != (1U << (max_codeword_len - 1)) ||
-			    len_counts[1] != 1)
-				return false;
-			sym = sorted_syms[0];
-		}
-		entry = make_decode_table_entry(decode_results, sym, 1);
-		for (i = 0; i < (1U << table_bits); i++)
-			decode_table[i] = entry;
-		return true;
-	}
-
-	/*
-	 * The lengths form a complete code.  Now, enumerate the codewords in
-	 * lexicographic order and fill the decode table entries for each one.
-	 *
-	 * First, process all codewords with len <= table_bits.  Each one gets
-	 * '2^(table_bits-len)' direct entries in the table.
-	 *
-	 * Since DEFLATE uses bit-reversed codewords, these entries aren't
-	 * consecutive but rather are spaced '2^len' entries apart.  This makes
-	 * filling them naively somewhat awkward and inefficient, since strided
-	 * stores are less cache-friendly and preclude the use of word or
-	 * vector-at-a-time stores to fill multiple entries per instruction.
-	 *
-	 * To optimize this, we incrementally double the table size.  When
-	 * processing codewords with length 'len', the table is treated as
-	 * having only '2^len' entries, so each codeword uses just one entry.
-	 * Then, each time 'len' is incremented, the table size is doubled and
-	 * the first half is copied to the second half.  This significantly
-	 * improves performance over naively doing strided stores.
-	 *
-	 * Note that some entries copied for each table doubling may not have
-	 * been initialized yet, but it doesn't matter since they're guaranteed
-	 * to be initialized later (because the Huffman code is complete).
-	 */
-	codeword = 0;
-	len = 1;
-	while ((count = len_counts[len]) == 0)
-		len++;
-	cur_table_end = 1U << len;
-	while (len <= table_bits) {
-		/* Process all 'count' codewords with length 'len' bits. */
-		do {
-			unsigned bit;
-
-			/* Fill the first entry for the current codeword. */
-			decode_table[codeword] =
-				make_decode_table_entry(decode_results,
-							*sorted_syms++, len);
-
-			if (codeword == cur_table_end - 1) {
-				/* Last codeword (all 1's) */
-				for (; len < table_bits; len++) {
-					memcpy(&decode_table[cur_table_end],
-					       decode_table,
-					       cur_table_end *
-						sizeof(decode_table[0]));
-					cur_table_end <<= 1;
-				}
-				return true;
-			}
-			/*
-			 * To advance to the lexicographically next codeword in
-			 * the canonical code, the codeword must be incremented,
-			 * then 0's must be appended to the codeword as needed
-			 * to match the next codeword's length.
-			 *
-			 * Since the codeword is bit-reversed, appending 0's is
-			 * a no-op.  However, incrementing it is nontrivial.  To
-			 * do so efficiently, use the 'bsr' instruction to find
-			 * the last (highest order) 0 bit in the codeword, set
-			 * it, and clear any later (higher order) 1 bits.  But
-			 * 'bsr' actually finds the highest order 1 bit, so to
-			 * use it first flip all bits in the codeword by XOR'ing
-			 * it with (1U << len) - 1 == cur_table_end - 1.
-			 */
-			bit = 1U << bsr32(codeword ^ (cur_table_end - 1));
-			codeword &= bit - 1;
-			codeword |= bit;
-		} while (--count);
-
-		/* Advance to the next codeword length. */
-		do {
-			if (++len <= table_bits) {
-				memcpy(&decode_table[cur_table_end],
-				       decode_table,
-				       cur_table_end * sizeof(decode_table[0]));
-				cur_table_end <<= 1;
-			}
-		} while ((count = len_counts[len]) == 0);
-	}
-
-	/* Process codewords with len > table_bits.  These require subtables. */
-	cur_table_end = 1U << table_bits;
-	subtable_prefix = -1;
-	subtable_start = 0;
-	for (;;) {
-		u32 entry;
-		unsigned i;
-		unsigned stride;
-		unsigned bit;
-
-		/*
-		 * Start a new subtable if the first 'table_bits' bits of the
-		 * codeword don't match the prefix of the current subtable.
-		 */
-		if ((codeword & ((1U << table_bits) - 1)) != subtable_prefix) {
-			subtable_prefix = (codeword & ((1U << table_bits) - 1));
-			subtable_start = cur_table_end;
-			/*
-			 * Calculate the subtable length.  If the codeword has
-			 * length 'table_bits + n', then the subtable needs
-			 * '2^n' entries.  But it may need more; if fewer than
-			 * '2^n' codewords of length 'table_bits + n' remain,
-			 * then the length will need to be incremented to bring
-			 * in longer codewords until the subtable can be
-			 * completely filled.  Note that because the Huffman
-			 * code is complete, it will always be possible to fill
-			 * the subtable eventually.
-			 */
-			subtable_bits = len - table_bits;
-			codespace_used = count;
-			while (codespace_used < (1U << subtable_bits)) {
-				subtable_bits++;
-				codespace_used = (codespace_used << 1) +
-					len_counts[table_bits + subtable_bits];
-			}
-			cur_table_end = subtable_start + (1U << subtable_bits);
-
-			/*
-			 * Create the entry that points from the main table to
-			 * the subtable.
-			 */
-			decode_table[subtable_prefix] =
-				((u32)subtable_start << 16) |
-				HUFFDEC_EXCEPTIONAL |
-				HUFFDEC_SUBTABLE_POINTER |
-				(subtable_bits << 8) | table_bits;
-		}
-
-		/* Fill the subtable entries for the current codeword. */
-		entry = make_decode_table_entry(decode_results, *sorted_syms++,
-						len - table_bits);
-		i = subtable_start + (codeword >> table_bits);
-		stride = 1U << (len - table_bits);
-		do {
-			decode_table[i] = entry;
-			i += stride;
-		} while (i < cur_table_end);
-
-		/* Advance to the next codeword. */
-		if (codeword == (1U << len) - 1) /* last codeword (all 1's)? */
-			return true;
-		bit = 1U << bsr32(codeword ^ ((1U << len) - 1));
-		codeword &= bit - 1;
-		codeword |= bit;
-		count--;
-		while (count == 0)
-			count = len_counts[++len];
-	}
-}
-
-/* Build the decode table for the precode.  */
-static bool
-build_precode_decode_table(struct libdeflate_decompressor *d)
-{
-	/* When you change TABLEBITS, you must change ENOUGH, and vice versa! */
-	STATIC_ASSERT(PRECODE_TABLEBITS == 7 && PRECODE_ENOUGH == 128);
-
-	STATIC_ASSERT(ARRAY_LEN(precode_decode_results) ==
-		      DEFLATE_NUM_PRECODE_SYMS);
-
-	return build_decode_table(d->u.l.precode_decode_table,
-				  d->u.precode_lens,
-				  DEFLATE_NUM_PRECODE_SYMS,
-				  precode_decode_results,
-				  PRECODE_TABLEBITS,
-				  DEFLATE_MAX_PRE_CODEWORD_LEN,
-				  d->sorted_syms,
-				  NULL);
-}
-
-/* Build the decode table for the literal/length code.  */
-static bool
-build_litlen_decode_table(struct libdeflate_decompressor *d,
-			  unsigned num_litlen_syms, unsigned num_offset_syms)
-{
-	/* When you change TABLEBITS, you must change ENOUGH, and vice versa! */
-	STATIC_ASSERT(LITLEN_TABLEBITS == 11 && LITLEN_ENOUGH == 2342);
-
-	STATIC_ASSERT(ARRAY_LEN(litlen_decode_results) ==
-		      DEFLATE_NUM_LITLEN_SYMS);
-
-	return build_decode_table(d->u.litlen_decode_table,
-				  d->u.l.lens,
-				  num_litlen_syms,
-				  litlen_decode_results,
-				  LITLEN_TABLEBITS,
-				  DEFLATE_MAX_LITLEN_CODEWORD_LEN,
-				  d->sorted_syms,
-				  &d->litlen_tablebits);
-}
-
-/* Build the decode table for the offset code.  */
-static bool
-build_offset_decode_table(struct libdeflate_decompressor *d,
-			  unsigned num_litlen_syms, unsigned num_offset_syms)
-{
-	/* When you change TABLEBITS, you must change ENOUGH, and vice versa! */
-	STATIC_ASSERT(OFFSET_TABLEBITS == 8 && OFFSET_ENOUGH == 402);
-
-	STATIC_ASSERT(ARRAY_LEN(offset_decode_results) ==
-		      DEFLATE_NUM_OFFSET_SYMS);
-
-	return build_decode_table(d->offset_decode_table,
-				  d->u.l.lens + num_litlen_syms,
-				  num_offset_syms,
-				  offset_decode_results,
-				  OFFSET_TABLEBITS,
-				  DEFLATE_MAX_OFFSET_CODEWORD_LEN,
-				  d->sorted_syms,
-				  NULL);
-}
-
-/*****************************************************************************
- *                         Main decompression routine
- *****************************************************************************/
-
-typedef enum libdeflate_result (*decompress_func_t)
-	(struct libdeflate_decompressor * restrict d,
-	 const void * restrict in, size_t in_nbytes,
-	 void * restrict out, size_t out_nbytes_avail,
-	 size_t *actual_in_nbytes_ret, size_t *actual_out_nbytes_ret);
-
-#define FUNCNAME deflate_decompress_default
-#undef ATTRIBUTES
-#undef EXTRACT_VARBITS
-#undef EXTRACT_VARBITS8
-#include "decompress_template.h"
-
-/* Include architecture-specific implementation(s) if available. */
-#undef DEFAULT_IMPL
-#undef arch_select_decompress_func
-#if defined(ARCH_X86_32) || defined(ARCH_X86_64)
-#  include "x86/decompress_impl.h"
-#endif
-
-#ifndef DEFAULT_IMPL
-#  define DEFAULT_IMPL deflate_decompress_default
-#endif
-
-#ifdef arch_select_decompress_func
-static enum libdeflate_result
-dispatch_decomp(struct libdeflate_decompressor * restrict d,
-		const void * restrict in, size_t in_nbytes,
-		void * restrict out, size_t out_nbytes_avail,
-		size_t *actual_in_nbytes_ret, size_t *actual_out_nbytes_ret);
-
-static volatile decompress_func_t decompress_impl = dispatch_decomp;
-
-/* Choose the best implementation at runtime. */
-static enum libdeflate_result
-dispatch_decomp(struct libdeflate_decompressor * restrict d,
-		const void * restrict in, size_t in_nbytes,
-		void * restrict out, size_t out_nbytes_avail,
-		size_t *actual_in_nbytes_ret, size_t *actual_out_nbytes_ret)
-{
-	decompress_func_t f = arch_select_decompress_func();
-
-	if (f == NULL)
-		f = DEFAULT_IMPL;
-
-	decompress_impl = f;
-	return f(d, in, in_nbytes, out, out_nbytes_avail,
-		 actual_in_nbytes_ret, actual_out_nbytes_ret);
-}
-#else
-/* The best implementation is statically known, so call it directly. */
-#  define decompress_impl DEFAULT_IMPL
-#endif
-
-/*
- * This is the main DEFLATE decompression routine.  See libdeflate.h for the
- * documentation.
- *
- * Note that the real code is in decompress_template.h.  The part here just
- * handles calling the appropriate implementation depending on the CPU features
- * at runtime.
- */
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_deflate_decompress_ex(struct libdeflate_decompressor *d,
-				 const void *in, size_t in_nbytes,
-				 void *out, size_t out_nbytes_avail,
-				 size_t *actual_in_nbytes_ret,
-				 size_t *actual_out_nbytes_ret)
-{
-	return decompress_impl(d, in, in_nbytes, out, out_nbytes_avail,
-			       actual_in_nbytes_ret, actual_out_nbytes_ret);
-}
-
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_deflate_decompress(struct libdeflate_decompressor *d,
-			      const void *in, size_t in_nbytes,
-			      void *out, size_t out_nbytes_avail,
-			      size_t *actual_out_nbytes_ret)
-{
-	return libdeflate_deflate_decompress_ex(d, in, in_nbytes,
-						out, out_nbytes_avail,
-						NULL, actual_out_nbytes_ret);
-}
-
-LIBDEFLATEAPI struct libdeflate_decompressor *
-libdeflate_alloc_decompressor_ex(const struct libdeflate_options *options)
-{
-	struct libdeflate_decompressor *d;
-
-	/*
-	 * Note: if more fields are added to libdeflate_options, this code will
-	 * need to be updated to support both the old and new structs.
-	 */
-	if (options->sizeof_options != sizeof(*options))
-		return NULL;
-
-	d = (options->malloc_func ? options->malloc_func :
-	     libdeflate_default_malloc_func)(sizeof(*d));
-	if (d == NULL)
-		return NULL;
-	/*
-	 * Note that only certain parts of the decompressor actually must be
-	 * initialized here:
-	 *
-	 * - 'static_codes_loaded' must be initialized to false.
-	 *
-	 * - The first half of the main portion of each decode table must be
-	 *   initialized to any value, to avoid reading from uninitialized
-	 *   memory during table expansion in build_decode_table().  (Although,
-	 *   this is really just to avoid warnings with dynamic tools like
-	 *   valgrind, since build_decode_table() is guaranteed to initialize
-	 *   all entries eventually anyway.)
-	 *
-	 * - 'free_func' must be set.
-	 *
-	 * But for simplicity, we currently just zero the whole decompressor.
-	 */
-	memset(d, 0, sizeof(*d));
-	d->free_func = options->free_func ?
-		       options->free_func : libdeflate_default_free_func;
-	return d;
-}
-
-LIBDEFLATEAPI struct libdeflate_decompressor *
-libdeflate_alloc_decompressor(void)
-{
-	static const struct libdeflate_options defaults = {
-		.sizeof_options = sizeof(defaults),
-	};
-	return libdeflate_alloc_decompressor_ex(&defaults);
-}
-
-LIBDEFLATEAPI void
-libdeflate_free_decompressor(struct libdeflate_decompressor *d)
-{
-	if (d)
-		d->free_func(d);
-}
diff --git a/vendor/core/vendor/libdeflate/lib/gzip_compress.c b/vendor/core/vendor/libdeflate/lib/gzip_compress.c
deleted file mode 100644
index b7d5076e..00000000
--- a/vendor/core/vendor/libdeflate/lib/gzip_compress.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * gzip_compress.c - compress with a gzip wrapper
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "deflate_compress.h"
-#include "gzip_constants.h"
-
-LIBDEFLATEAPI size_t
-libdeflate_gzip_compress(struct libdeflate_compressor *c,
-			 const void *in, size_t in_nbytes,
-			 void *out, size_t out_nbytes_avail)
-{
-	u8 *out_next = out;
-	unsigned compression_level;
-	u8 xfl;
-	size_t deflate_size;
-
-	if (out_nbytes_avail <= GZIP_MIN_OVERHEAD)
-		return 0;
-
-	/* ID1 */
-	*out_next++ = GZIP_ID1;
-	/* ID2 */
-	*out_next++ = GZIP_ID2;
-	/* CM */
-	*out_next++ = GZIP_CM_DEFLATE;
-	/* FLG */
-	*out_next++ = 0;
-	/* MTIME */
-	put_unaligned_le32(GZIP_MTIME_UNAVAILABLE, out_next);
-	out_next += 4;
-	/* XFL */
-	xfl = 0;
-	compression_level = libdeflate_get_compression_level(c);
-	if (compression_level < 2)
-		xfl |= GZIP_XFL_FASTEST_COMPRESSION;
-	else if (compression_level >= 8)
-		xfl |= GZIP_XFL_SLOWEST_COMPRESSION;
-	*out_next++ = xfl;
-	/* OS */
-	*out_next++ = GZIP_OS_UNKNOWN;	/* OS  */
-
-	/* Compressed data  */
-	deflate_size = libdeflate_deflate_compress(c, in, in_nbytes, out_next,
-					out_nbytes_avail - GZIP_MIN_OVERHEAD);
-	if (deflate_size == 0)
-		return 0;
-	out_next += deflate_size;
-
-	/* CRC32 */
-	put_unaligned_le32(libdeflate_crc32(0, in, in_nbytes), out_next);
-	out_next += 4;
-
-	/* ISIZE */
-	put_unaligned_le32((u32)in_nbytes, out_next);
-	out_next += 4;
-
-	return out_next - (u8 *)out;
-}
-
-LIBDEFLATEAPI size_t
-libdeflate_gzip_compress_bound(struct libdeflate_compressor *c,
-			       size_t in_nbytes)
-{
-	return GZIP_MIN_OVERHEAD +
-	       libdeflate_deflate_compress_bound(c, in_nbytes);
-}
diff --git a/vendor/core/vendor/libdeflate/lib/gzip_constants.h b/vendor/core/vendor/libdeflate/lib/gzip_constants.h
deleted file mode 100644
index 35e4728d..00000000
--- a/vendor/core/vendor/libdeflate/lib/gzip_constants.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * gzip_constants.h - constants for the gzip wrapper format
- */
-
-#ifndef LIB_GZIP_CONSTANTS_H
-#define LIB_GZIP_CONSTANTS_H
-
-#define GZIP_MIN_HEADER_SIZE	10
-#define GZIP_FOOTER_SIZE	8
-#define GZIP_MIN_OVERHEAD	(GZIP_MIN_HEADER_SIZE + GZIP_FOOTER_SIZE)
-
-#define GZIP_ID1		0x1F
-#define GZIP_ID2		0x8B
-
-#define GZIP_CM_DEFLATE		8
-
-#define GZIP_FTEXT		0x01
-#define GZIP_FHCRC		0x02
-#define GZIP_FEXTRA		0x04
-#define GZIP_FNAME		0x08
-#define GZIP_FCOMMENT		0x10
-#define GZIP_FRESERVED		0xE0
-
-#define GZIP_MTIME_UNAVAILABLE	0
-
-#define GZIP_XFL_SLOWEST_COMPRESSION	0x02
-#define GZIP_XFL_FASTEST_COMPRESSION	0x04
-
-#define GZIP_OS_FAT		0
-#define GZIP_OS_AMIGA		1
-#define GZIP_OS_VMS		2
-#define GZIP_OS_UNIX		3
-#define GZIP_OS_VM_CMS		4
-#define GZIP_OS_ATARI_TOS	5
-#define GZIP_OS_HPFS		6
-#define GZIP_OS_MACINTOSH	7
-#define GZIP_OS_Z_SYSTEM	8
-#define GZIP_OS_CP_M		9
-#define GZIP_OS_TOPS_20		10
-#define GZIP_OS_NTFS		11
-#define GZIP_OS_QDOS		12
-#define GZIP_OS_RISCOS		13
-#define GZIP_OS_UNKNOWN		255
-
-#endif /* LIB_GZIP_CONSTANTS_H */
diff --git a/vendor/core/vendor/libdeflate/lib/gzip_decompress.c b/vendor/core/vendor/libdeflate/lib/gzip_decompress.c
deleted file mode 100644
index 76b74f69..00000000
--- a/vendor/core/vendor/libdeflate/lib/gzip_decompress.c
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * gzip_decompress.c - decompress with a gzip wrapper
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "lib_common.h"
-#include "gzip_constants.h"
-
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_gzip_decompress_ex(struct libdeflate_decompressor *d,
-			      const void *in, size_t in_nbytes,
-			      void *out, size_t out_nbytes_avail,
-			      size_t *actual_in_nbytes_ret,
-			      size_t *actual_out_nbytes_ret)
-{
-	const u8 *in_next = in;
-	const u8 * const in_end = in_next + in_nbytes;
-	u8 flg;
-	size_t actual_in_nbytes;
-	size_t actual_out_nbytes;
-	enum libdeflate_result result;
-
-	if (in_nbytes < GZIP_MIN_OVERHEAD)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* ID1 */
-	if (*in_next++ != GZIP_ID1)
-		return LIBDEFLATE_BAD_DATA;
-	/* ID2 */
-	if (*in_next++ != GZIP_ID2)
-		return LIBDEFLATE_BAD_DATA;
-	/* CM */
-	if (*in_next++ != GZIP_CM_DEFLATE)
-		return LIBDEFLATE_BAD_DATA;
-	flg = *in_next++;
-	/* MTIME */
-	in_next += 4;
-	/* XFL */
-	in_next += 1;
-	/* OS */
-	in_next += 1;
-
-	if (flg & GZIP_FRESERVED)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* Extra field */
-	if (flg & GZIP_FEXTRA) {
-		u16 xlen = get_unaligned_le16(in_next);
-		in_next += 2;
-
-		if (in_end - in_next < (u32)xlen + GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-
-		in_next += xlen;
-	}
-
-	/* Original file name (zero terminated) */
-	if (flg & GZIP_FNAME) {
-		while (*in_next++ != 0 && in_next != in_end)
-			;
-		if (in_end - in_next < GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-	}
-
-	/* File comment (zero terminated) */
-	if (flg & GZIP_FCOMMENT) {
-		while (*in_next++ != 0 && in_next != in_end)
-			;
-		if (in_end - in_next < GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-	}
-
-	/* CRC16 for gzip header */
-	if (flg & GZIP_FHCRC) {
-		in_next += 2;
-		if (in_end - in_next < GZIP_FOOTER_SIZE)
-			return LIBDEFLATE_BAD_DATA;
-	}
-
-	/* Compressed data  */
-	result = libdeflate_deflate_decompress_ex(d, in_next,
-					in_end - GZIP_FOOTER_SIZE - in_next,
-					out, out_nbytes_avail,
-					&actual_in_nbytes,
-					actual_out_nbytes_ret);
-	if (result != LIBDEFLATE_SUCCESS)
-		return result;
-
-	if (actual_out_nbytes_ret)
-		actual_out_nbytes = *actual_out_nbytes_ret;
-	else
-		actual_out_nbytes = out_nbytes_avail;
-
-	in_next += actual_in_nbytes;
-
-	/* CRC32 */
-	if (libdeflate_crc32(0, out, actual_out_nbytes) !=
-	    get_unaligned_le32(in_next))
-		return LIBDEFLATE_BAD_DATA;
-	in_next += 4;
-
-	/* ISIZE */
-	if ((u32)actual_out_nbytes != get_unaligned_le32(in_next))
-		return LIBDEFLATE_BAD_DATA;
-	in_next += 4;
-
-	if (actual_in_nbytes_ret)
-		*actual_in_nbytes_ret = in_next - (u8 *)in;
-
-	return LIBDEFLATE_SUCCESS;
-}
-
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_gzip_decompress(struct libdeflate_decompressor *d,
-			   const void *in, size_t in_nbytes,
-			   void *out, size_t out_nbytes_avail,
-			   size_t *actual_out_nbytes_ret)
-{
-	return libdeflate_gzip_decompress_ex(d, in, in_nbytes,
-					     out, out_nbytes_avail,
-					     NULL, actual_out_nbytes_ret);
-}
diff --git a/vendor/core/vendor/libdeflate/lib/hc_matchfinder.h b/vendor/core/vendor/libdeflate/lib/hc_matchfinder.h
deleted file mode 100644
index a0cddfca..00000000
--- a/vendor/core/vendor/libdeflate/lib/hc_matchfinder.h
+++ /dev/null
@@ -1,401 +0,0 @@
-/*
- * hc_matchfinder.h - Lempel-Ziv matchfinding with a hash table of linked lists
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- *
- * ---------------------------------------------------------------------------
- *
- *				   Algorithm
- *
- * This is a Hash Chains (hc) based matchfinder.
- *
- * The main data structure is a hash table where each hash bucket contains a
- * linked list (or "chain") of sequences whose first 4 bytes share the same hash
- * code.  Each sequence is identified by its starting position in the input
- * buffer.
- *
- * The algorithm processes the input buffer sequentially.  At each byte
- * position, the hash code of the first 4 bytes of the sequence beginning at
- * that position (the sequence being matched against) is computed.  This
- * identifies the hash bucket to use for that position.  Then, this hash
- * bucket's linked list is searched for matches.  Then, a new linked list node
- * is created to represent the current sequence and is prepended to the list.
- *
- * This algorithm has several useful properties:
- *
- * - It only finds true Lempel-Ziv matches; i.e., those where the matching
- *   sequence occurs prior to the sequence being matched against.
- *
- * - The sequences in each linked list are always sorted by decreasing starting
- *   position.  Therefore, the closest (smallest offset) matches are found
- *   first, which in many compression formats tend to be the cheapest to encode.
- *
- * - Although fast running time is not guaranteed due to the possibility of the
- *   lists getting very long, the worst degenerate behavior can be easily
- *   prevented by capping the number of nodes searched at each position.
- *
- * - If the compressor decides not to search for matches at a certain position,
- *   then that position can be quickly inserted without searching the list.
- *
- * - The algorithm is adaptable to sliding windows: just store the positions
- *   relative to a "base" value that is updated from time to time, and stop
- *   searching each list when the sequences get too far away.
- *
- * ----------------------------------------------------------------------------
- *
- *				 Optimizations
- *
- * The main hash table and chains handle length 4+ matches.  Length 3 matches
- * are handled by a separate hash table with no chains.  This works well for
- * typical "greedy" or "lazy"-style compressors, where length 3 matches are
- * often only helpful if they have small offsets.  Instead of searching a full
- * chain for length 3+ matches, the algorithm just checks for one close length 3
- * match, then focuses on finding length 4+ matches.
- *
- * The longest_match() and skip_bytes() functions are inlined into the
- * compressors that use them.  This isn't just about saving the overhead of a
- * function call.  These functions are intended to be called from the inner
- * loops of compressors, where giving the compiler more control over register
- * allocation is very helpful.  There is also significant benefit to be gained
- * from allowing the CPU to predict branches independently at each call site.
- * For example, "lazy"-style compressors can be written with two calls to
- * longest_match(), each of which starts with a different 'best_len' and
- * therefore has significantly different performance characteristics.
- *
- * Although any hash function can be used, a multiplicative hash is fast and
- * works well.
- *
- * On some processors, it is significantly faster to extend matches by whole
- * words (32 or 64 bits) instead of by individual bytes.  For this to be the
- * case, the processor must implement unaligned memory accesses efficiently and
- * must have either a fast "find first set bit" instruction or a fast "find last
- * set bit" instruction, depending on the processor's endianness.
- *
- * The code uses one loop for finding the first match and one loop for finding a
- * longer match.  Each of these loops is tuned for its respective task and in
- * combination are faster than a single generalized loop that handles both
- * tasks.
- *
- * The code also uses a tight inner loop that only compares the last and first
- * bytes of a potential match.  It is only when these bytes match that a full
- * match extension is attempted.
- *
- * ----------------------------------------------------------------------------
- */
-
-#ifndef LIB_HC_MATCHFINDER_H
-#define LIB_HC_MATCHFINDER_H
-
-#include "matchfinder_common.h"
-
-#define HC_MATCHFINDER_HASH3_ORDER	15
-#define HC_MATCHFINDER_HASH4_ORDER	16
-
-#define HC_MATCHFINDER_TOTAL_HASH_SIZE			\
-	(((1UL << HC_MATCHFINDER_HASH3_ORDER) +		\
-	  (1UL << HC_MATCHFINDER_HASH4_ORDER)) * sizeof(mf_pos_t))
-
-struct MATCHFINDER_ALIGNED hc_matchfinder  {
-
-	/* The hash table for finding length 3 matches  */
-	mf_pos_t hash3_tab[1UL << HC_MATCHFINDER_HASH3_ORDER];
-
-	/* The hash table which contains the first nodes of the linked lists for
-	 * finding length 4+ matches  */
-	mf_pos_t hash4_tab[1UL << HC_MATCHFINDER_HASH4_ORDER];
-
-	/* The "next node" references for the linked lists.  The "next node" of
-	 * the node for the sequence with position 'pos' is 'next_tab[pos]'.  */
-	mf_pos_t next_tab[MATCHFINDER_WINDOW_SIZE];
-};
-
-/* Prepare the matchfinder for a new input buffer.  */
-static forceinline void
-hc_matchfinder_init(struct hc_matchfinder *mf)
-{
-	STATIC_ASSERT(HC_MATCHFINDER_TOTAL_HASH_SIZE %
-		      MATCHFINDER_SIZE_ALIGNMENT == 0);
-
-	matchfinder_init((mf_pos_t *)mf, HC_MATCHFINDER_TOTAL_HASH_SIZE);
-}
-
-static forceinline void
-hc_matchfinder_slide_window(struct hc_matchfinder *mf)
-{
-	STATIC_ASSERT(sizeof(*mf) % MATCHFINDER_SIZE_ALIGNMENT == 0);
-
-	matchfinder_rebase((mf_pos_t *)mf, sizeof(*mf));
-}
-
-/*
- * Find the longest match longer than 'best_len' bytes.
- *
- * @mf
- *	The matchfinder structure.
- * @in_base_p
- *	Location of a pointer which points to the place in the input data the
- *	matchfinder currently stores positions relative to.  This may be updated
- *	by this function.
- * @in_next
- *	Pointer to the next position in the input buffer, i.e. the sequence
- *	being matched against.
- * @best_len
- *	Require a match longer than this length.
- * @max_len
- *	The maximum permissible match length at this position.
- * @nice_len
- *	Stop searching if a match of at least this length is found.
- *	Must be <= @max_len.
- * @max_search_depth
- *	Limit on the number of potential matches to consider.  Must be >= 1.
- * @next_hashes
- *	The precomputed hash codes for the sequence beginning at @in_next.
- *	These will be used and then updated with the precomputed hashcodes for
- *	the sequence beginning at @in_next + 1.
- * @offset_ret
- *	If a match is found, its offset is returned in this location.
- *
- * Return the length of the match found, or 'best_len' if no match longer than
- * 'best_len' was found.
- */
-static forceinline u32
-hc_matchfinder_longest_match(struct hc_matchfinder * const mf,
-			     const u8 ** const in_base_p,
-			     const u8 * const in_next,
-			     u32 best_len,
-			     const u32 max_len,
-			     const u32 nice_len,
-			     const u32 max_search_depth,
-			     u32 * const next_hashes,
-			     u32 * const offset_ret)
-{
-	u32 depth_remaining = max_search_depth;
-	const u8 *best_matchptr = in_next;
-	mf_pos_t cur_node3, cur_node4;
-	u32 hash3, hash4;
-	u32 next_hashseq;
-	u32 seq4;
-	const u8 *matchptr;
-	u32 len;
-	u32 cur_pos = in_next - *in_base_p;
-	const u8 *in_base;
-	mf_pos_t cutoff;
-
-	if (cur_pos == MATCHFINDER_WINDOW_SIZE) {
-		hc_matchfinder_slide_window(mf);
-		*in_base_p += MATCHFINDER_WINDOW_SIZE;
-		cur_pos = 0;
-	}
-
-	in_base = *in_base_p;
-	cutoff = cur_pos - MATCHFINDER_WINDOW_SIZE;
-
-	if (unlikely(max_len < 5)) /* can we read 4 bytes from 'in_next + 1'? */
-		goto out;
-
-	/* Get the precomputed hash codes.  */
-	hash3 = next_hashes[0];
-	hash4 = next_hashes[1];
-
-	/* From the hash buckets, get the first node of each linked list.  */
-	cur_node3 = mf->hash3_tab[hash3];
-	cur_node4 = mf->hash4_tab[hash4];
-
-	/* Update for length 3 matches.  This replaces the singleton node in the
-	 * 'hash3' bucket with the node for the current sequence.  */
-	mf->hash3_tab[hash3] = cur_pos;
-
-	/* Update for length 4 matches.  This prepends the node for the current
-	 * sequence to the linked list in the 'hash4' bucket.  */
-	mf->hash4_tab[hash4] = cur_pos;
-	mf->next_tab[cur_pos] = cur_node4;
-
-	/* Compute the next hash codes.  */
-	next_hashseq = get_unaligned_le32(in_next + 1);
-	next_hashes[0] = lz_hash(next_hashseq & 0xFFFFFF, HC_MATCHFINDER_HASH3_ORDER);
-	next_hashes[1] = lz_hash(next_hashseq, HC_MATCHFINDER_HASH4_ORDER);
-	prefetchw(&mf->hash3_tab[next_hashes[0]]);
-	prefetchw(&mf->hash4_tab[next_hashes[1]]);
-
-	if (best_len < 4) {  /* No match of length >= 4 found yet?  */
-
-		/* Check for a length 3 match if needed.  */
-
-		if (cur_node3 <= cutoff)
-			goto out;
-
-		seq4 = load_u32_unaligned(in_next);
-
-		if (best_len < 3) {
-			matchptr = &in_base[cur_node3];
-			if (load_u24_unaligned(matchptr) == loaded_u32_to_u24(seq4)) {
-				best_len = 3;
-				best_matchptr = matchptr;
-			}
-		}
-
-		/* Check for a length 4 match.  */
-
-		if (cur_node4 <= cutoff)
-			goto out;
-
-		for (;;) {
-			/* No length 4 match found yet.  Check the first 4 bytes.  */
-			matchptr = &in_base[cur_node4];
-
-			if (load_u32_unaligned(matchptr) == seq4)
-				break;
-
-			/* The first 4 bytes did not match.  Keep trying.  */
-			cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-			if (cur_node4 <= cutoff || !--depth_remaining)
-				goto out;
-		}
-
-		/* Found a match of length >= 4.  Extend it to its full length.  */
-		best_matchptr = matchptr;
-		best_len = lz_extend(in_next, best_matchptr, 4, max_len);
-		if (best_len >= nice_len)
-			goto out;
-		cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-		if (cur_node4 <= cutoff || !--depth_remaining)
-			goto out;
-	} else {
-		if (cur_node4 <= cutoff || best_len >= nice_len)
-			goto out;
-	}
-
-	/* Check for matches of length >= 5.  */
-
-	for (;;) {
-		for (;;) {
-			matchptr = &in_base[cur_node4];
-
-			/* Already found a length 4 match.  Try for a longer
-			 * match; start by checking either the last 4 bytes and
-			 * the first 4 bytes, or the last byte.  (The last byte,
-			 * the one which would extend the match length by 1, is
-			 * the most important.)  */
-		#if UNALIGNED_ACCESS_IS_FAST
-			if ((load_u32_unaligned(matchptr + best_len - 3) ==
-			     load_u32_unaligned(in_next + best_len - 3)) &&
-			    (load_u32_unaligned(matchptr) ==
-			     load_u32_unaligned(in_next)))
-		#else
-			if (matchptr[best_len] == in_next[best_len])
-		#endif
-				break;
-
-			/* Continue to the next node in the list.  */
-			cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-			if (cur_node4 <= cutoff || !--depth_remaining)
-				goto out;
-		}
-
-	#if UNALIGNED_ACCESS_IS_FAST
-		len = 4;
-	#else
-		len = 0;
-	#endif
-		len = lz_extend(in_next, matchptr, len, max_len);
-		if (len > best_len) {
-			/* This is the new longest match.  */
-			best_len = len;
-			best_matchptr = matchptr;
-			if (best_len >= nice_len)
-				goto out;
-		}
-
-		/* Continue to the next node in the list.  */
-		cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)];
-		if (cur_node4 <= cutoff || !--depth_remaining)
-			goto out;
-	}
-out:
-	*offset_ret = in_next - best_matchptr;
-	return best_len;
-}
-
-/*
- * Advance the matchfinder, but don't search for matches.
- *
- * @mf
- *	The matchfinder structure.
- * @in_base_p
- *	Location of a pointer which points to the place in the input data the
- *	matchfinder currently stores positions relative to.  This may be updated
- *	by this function.
- * @in_next
- *	Pointer to the next position in the input buffer.
- * @in_end
- *	Pointer to the end of the input buffer.
- * @count
- *	The number of bytes to advance.  Must be > 0.
- * @next_hashes
- *	The precomputed hash codes for the sequence beginning at @in_next.
- *	These will be used and then updated with the precomputed hashcodes for
- *	the sequence beginning at @in_next + @count.
- */
-static forceinline void
-hc_matchfinder_skip_bytes(struct hc_matchfinder * const mf,
-			  const u8 ** const in_base_p,
-			  const u8 *in_next,
-			  const u8 * const in_end,
-			  const u32 count,
-			  u32 * const next_hashes)
-{
-	u32 cur_pos;
-	u32 hash3, hash4;
-	u32 next_hashseq;
-	u32 remaining = count;
-
-	if (unlikely(count + 5 > in_end - in_next))
-		return;
-
-	cur_pos = in_next - *in_base_p;
-	hash3 = next_hashes[0];
-	hash4 = next_hashes[1];
-	do {
-		if (cur_pos == MATCHFINDER_WINDOW_SIZE) {
-			hc_matchfinder_slide_window(mf);
-			*in_base_p += MATCHFINDER_WINDOW_SIZE;
-			cur_pos = 0;
-		}
-		mf->hash3_tab[hash3] = cur_pos;
-		mf->next_tab[cur_pos] = mf->hash4_tab[hash4];
-		mf->hash4_tab[hash4] = cur_pos;
-
-		next_hashseq = get_unaligned_le32(++in_next);
-		hash3 = lz_hash(next_hashseq & 0xFFFFFF, HC_MATCHFINDER_HASH3_ORDER);
-		hash4 = lz_hash(next_hashseq, HC_MATCHFINDER_HASH4_ORDER);
-		cur_pos++;
-	} while (--remaining);
-
-	prefetchw(&mf->hash3_tab[hash3]);
-	prefetchw(&mf->hash4_tab[hash4]);
-	next_hashes[0] = hash3;
-	next_hashes[1] = hash4;
-}
-
-#endif /* LIB_HC_MATCHFINDER_H */
diff --git a/vendor/core/vendor/libdeflate/lib/ht_matchfinder.h b/vendor/core/vendor/libdeflate/lib/ht_matchfinder.h
deleted file mode 100644
index 6e5a187c..00000000
--- a/vendor/core/vendor/libdeflate/lib/ht_matchfinder.h
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- * ht_matchfinder.h - Lempel-Ziv matchfinding with a hash table
- *
- * Copyright 2022 Eric Biggers
- *
- * 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.
- *
- * ---------------------------------------------------------------------------
- *
- * This is a Hash Table (ht) matchfinder.
- *
- * This is a variant of the Hash Chains (hc) matchfinder that is optimized for
- * very fast compression.  The ht_matchfinder stores the hash chains inline in
- * the hash table, whereas the hc_matchfinder stores them in a separate array.
- * Storing the hash chains inline is the faster method when max_search_depth
- * (the maximum chain length) is very small.  It is not appropriate when
- * max_search_depth is larger, as then it uses too much memory.
- *
- * Due to its focus on speed, the ht_matchfinder doesn't support length 3
- * matches.  It also doesn't allow max_search_depth to vary at runtime; it is
- * fixed at build time as HT_MATCHFINDER_BUCKET_SIZE.
- *
- * See hc_matchfinder.h for more information.
- */
-
-#ifndef LIB_HT_MATCHFINDER_H
-#define LIB_HT_MATCHFINDER_H
-
-#include "matchfinder_common.h"
-
-#define HT_MATCHFINDER_HASH_ORDER	15
-#define HT_MATCHFINDER_BUCKET_SIZE	2
-
-#define HT_MATCHFINDER_MIN_MATCH_LEN	4
-/* Minimum value of max_len for ht_matchfinder_longest_match() */
-#define HT_MATCHFINDER_REQUIRED_NBYTES	5
-
-struct MATCHFINDER_ALIGNED ht_matchfinder {
-	mf_pos_t hash_tab[1UL << HT_MATCHFINDER_HASH_ORDER]
-			 [HT_MATCHFINDER_BUCKET_SIZE];
-};
-
-static forceinline void
-ht_matchfinder_init(struct ht_matchfinder *mf)
-{
-	STATIC_ASSERT(sizeof(*mf) % MATCHFINDER_SIZE_ALIGNMENT == 0);
-
-	matchfinder_init((mf_pos_t *)mf, sizeof(*mf));
-}
-
-static forceinline void
-ht_matchfinder_slide_window(struct ht_matchfinder *mf)
-{
-	matchfinder_rebase((mf_pos_t *)mf, sizeof(*mf));
-}
-
-/* Note: max_len must be >= HT_MATCHFINDER_REQUIRED_NBYTES */
-static forceinline u32
-ht_matchfinder_longest_match(struct ht_matchfinder * const mf,
-			     const u8 ** const in_base_p,
-			     const u8 * const in_next,
-			     const u32 max_len,
-			     const u32 nice_len,
-			     u32 * const next_hash,
-			     u32 * const offset_ret)
-{
-	u32 best_len = 0;
-	const u8 *best_matchptr = in_next;
-	u32 cur_pos = in_next - *in_base_p;
-	const u8 *in_base;
-	mf_pos_t cutoff;
-	u32 hash;
-	u32 seq;
-	mf_pos_t cur_node;
-	const u8 *matchptr;
-#if HT_MATCHFINDER_BUCKET_SIZE > 1
-	mf_pos_t to_insert;
-	u32 len;
-#endif
-#if HT_MATCHFINDER_BUCKET_SIZE > 2
-	int i;
-#endif
-
-	/* This is assumed throughout this function. */
-	STATIC_ASSERT(HT_MATCHFINDER_MIN_MATCH_LEN == 4);
-
-	if (cur_pos == MATCHFINDER_WINDOW_SIZE) {
-		ht_matchfinder_slide_window(mf);
-		*in_base_p += MATCHFINDER_WINDOW_SIZE;
-		cur_pos = 0;
-	}
-	in_base = *in_base_p;
-	cutoff = cur_pos - MATCHFINDER_WINDOW_SIZE;
-
-	hash = *next_hash;
-	STATIC_ASSERT(HT_MATCHFINDER_REQUIRED_NBYTES == 5);
-	*next_hash = lz_hash(get_unaligned_le32(in_next + 1),
-			     HT_MATCHFINDER_HASH_ORDER);
-	seq = load_u32_unaligned(in_next);
-	prefetchw(&mf->hash_tab[*next_hash]);
-#if HT_MATCHFINDER_BUCKET_SIZE == 1
-	/* Hand-unrolled version for BUCKET_SIZE == 1 */
-	cur_node = mf->hash_tab[hash][0];
-	mf->hash_tab[hash][0] = cur_pos;
-	if (cur_node <= cutoff)
-		goto out;
-	matchptr = &in_base[cur_node];
-	if (load_u32_unaligned(matchptr) == seq) {
-		best_len = lz_extend(in_next, matchptr, 4, max_len);
-		best_matchptr = matchptr;
-	}
-#elif HT_MATCHFINDER_BUCKET_SIZE == 2
-	/*
-	 * Hand-unrolled version for BUCKET_SIZE == 2.  The logic here also
-	 * differs slightly in that it copies the first entry to the second even
-	 * if nice_len is reached on the first, as this can be slightly faster.
-	 */
-	cur_node = mf->hash_tab[hash][0];
-	mf->hash_tab[hash][0] = cur_pos;
-	if (cur_node <= cutoff)
-		goto out;
-	matchptr = &in_base[cur_node];
-
-	to_insert = cur_node;
-	cur_node = mf->hash_tab[hash][1];
-	mf->hash_tab[hash][1] = to_insert;
-
-	if (load_u32_unaligned(matchptr) == seq) {
-		best_len = lz_extend(in_next, matchptr, 4, max_len);
-		best_matchptr = matchptr;
-		if (cur_node <= cutoff || best_len >= nice_len)
-			goto out;
-		matchptr = &in_base[cur_node];
-		if (load_u32_unaligned(matchptr) == seq &&
-		    load_u32_unaligned(matchptr + best_len - 3) ==
-		    load_u32_unaligned(in_next + best_len - 3)) {
-			len = lz_extend(in_next, matchptr, 4, max_len);
-			if (len > best_len) {
-				best_len = len;
-				best_matchptr = matchptr;
-			}
-		}
-	} else {
-		if (cur_node <= cutoff)
-			goto out;
-		matchptr = &in_base[cur_node];
-		if (load_u32_unaligned(matchptr) == seq) {
-			best_len = lz_extend(in_next, matchptr, 4, max_len);
-			best_matchptr = matchptr;
-		}
-	}
-#else
-	/* Generic version for HT_MATCHFINDER_BUCKET_SIZE > 2 */
-	to_insert = cur_pos;
-	for (i = 0; i < HT_MATCHFINDER_BUCKET_SIZE; i++) {
-		cur_node = mf->hash_tab[hash][i];
-		mf->hash_tab[hash][i] = to_insert;
-		if (cur_node <= cutoff)
-			goto out;
-		matchptr = &in_base[cur_node];
-		if (load_u32_unaligned(matchptr) == seq) {
-			len = lz_extend(in_next, matchptr, 4, max_len);
-			if (len > best_len) {
-				best_len = len;
-				best_matchptr = matchptr;
-				if (best_len >= nice_len)
-					goto out;
-			}
-		}
-		to_insert = cur_node;
-	}
-#endif
-out:
-	*offset_ret = in_next - best_matchptr;
-	return best_len;
-}
-
-static forceinline void
-ht_matchfinder_skip_bytes(struct ht_matchfinder * const mf,
-			  const u8 ** const in_base_p,
-			  const u8 *in_next,
-			  const u8 * const in_end,
-			  const u32 count,
-			  u32 * const next_hash)
-{
-	s32 cur_pos = in_next - *in_base_p;
-	u32 hash;
-	u32 remaining = count;
-	int i;
-
-	if (unlikely(count + HT_MATCHFINDER_REQUIRED_NBYTES > in_end - in_next))
-		return;
-
-	if (cur_pos + count - 1 >= MATCHFINDER_WINDOW_SIZE) {
-		ht_matchfinder_slide_window(mf);
-		*in_base_p += MATCHFINDER_WINDOW_SIZE;
-		cur_pos -= MATCHFINDER_WINDOW_SIZE;
-	}
-
-	hash = *next_hash;
-	do {
-		for (i = HT_MATCHFINDER_BUCKET_SIZE - 1; i > 0; i--)
-			mf->hash_tab[hash][i] = mf->hash_tab[hash][i - 1];
-		mf->hash_tab[hash][0] = cur_pos;
-
-		hash = lz_hash(get_unaligned_le32(++in_next),
-			       HT_MATCHFINDER_HASH_ORDER);
-		cur_pos++;
-	} while (--remaining);
-
-	prefetchw(&mf->hash_tab[hash]);
-	*next_hash = hash;
-}
-
-#endif /* LIB_HT_MATCHFINDER_H */
diff --git a/vendor/core/vendor/libdeflate/lib/lib_common.h b/vendor/core/vendor/libdeflate/lib/lib_common.h
deleted file mode 100644
index 9246ca1e..00000000
--- a/vendor/core/vendor/libdeflate/lib/lib_common.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * lib_common.h - internal header included by all library code
- */
-
-#ifndef LIB_LIB_COMMON_H
-#define LIB_LIB_COMMON_H
-
-#ifdef LIBDEFLATE_H
- /*
-  * When building the library, LIBDEFLATEAPI needs to be defined properly before
-  * including libdeflate.h.
-  */
-#  error "lib_common.h must always be included before libdeflate.h"
-#endif
-
-/*
- * A build that compiles this library into a larger one does not want its
- * symbols marked for export, as they would then leave whatever binary it
- * ends up in.  Such a build can say so by defining this itself.
- */
-#ifndef LIBDEFLATE_EXPORT_SYM
-#if defined(LIBDEFLATE_DLL) && (defined(_WIN32) || defined(__CYGWIN__))
-#  define LIBDEFLATE_EXPORT_SYM  __declspec(dllexport)
-#elif defined(__GNUC__)
-#  define LIBDEFLATE_EXPORT_SYM  __attribute__((visibility("default")))
-#else
-#  define LIBDEFLATE_EXPORT_SYM
-#endif
-#endif
-
-/*
- * On i386, gcc assumes that the stack is 16-byte aligned at function entry.
- * However, some compilers (e.g. MSVC) and programming languages (e.g. Delphi)
- * only guarantee 4-byte alignment when calling functions.  This is mainly an
- * issue on Windows, but it has been seen on Linux too.  Work around this ABI
- * incompatibility by realigning the stack pointer when entering libdeflate.
- * This prevents crashes in SSE/AVX code.
- */
-#if defined(__GNUC__) && defined(__i386__)
-#  define LIBDEFLATE_ALIGN_STACK  __attribute__((force_align_arg_pointer))
-#else
-#  define LIBDEFLATE_ALIGN_STACK
-#endif
-
-#define LIBDEFLATEAPI	LIBDEFLATE_EXPORT_SYM LIBDEFLATE_ALIGN_STACK
-
-#include "../common_defs.h"
-
-typedef void *(*malloc_func_t)(size_t);
-typedef void (*free_func_t)(void *);
-
-extern malloc_func_t libdeflate_default_malloc_func;
-extern free_func_t libdeflate_default_free_func;
-
-void *libdeflate_aligned_malloc(malloc_func_t malloc_func,
-				size_t alignment, size_t size);
-void libdeflate_aligned_free(free_func_t free_func, void *ptr);
-
-#ifdef FREESTANDING
-/*
- * With -ffreestanding, <string.h> may be missing, and we must provide
- * implementations of memset(), memcpy(), memmove(), and memcmp().
- * See https://gcc.gnu.org/onlinedocs/gcc/Standards.html
- *
- * Also, -ffreestanding disables interpreting calls to these functions as
- * built-ins.  E.g., calling memcpy(&v, p, WORDBYTES) will make a function call,
- * not be optimized to a single load instruction.  For performance reasons we
- * don't want that.  So, declare these functions as macros that expand to the
- * corresponding built-ins.  This approach is recommended in the gcc man page.
- * We still need the actual function definitions in case gcc calls them.
- */
-void *memset(void *s, int c, size_t n);
-#define memset(s, c, n)		__builtin_memset((s), (c), (n))
-
-void *memcpy(void *dest, const void *src, size_t n);
-#define memcpy(dest, src, n)	__builtin_memcpy((dest), (src), (n))
-
-void *memmove(void *dest, const void *src, size_t n);
-#define memmove(dest, src, n)	__builtin_memmove((dest), (src), (n))
-
-int memcmp(const void *s1, const void *s2, size_t n);
-#define memcmp(s1, s2, n)	__builtin_memcmp((s1), (s2), (n))
-
-#undef LIBDEFLATE_ENABLE_ASSERTIONS
-#else
-#  include <string.h>
-   /*
-    * To prevent false positive static analyzer warnings, ensure that assertions
-    * are visible to the static analyzer.
-    */
-#  ifdef __clang_analyzer__
-#    define LIBDEFLATE_ENABLE_ASSERTIONS
-#  endif
-#endif
-
-/*
- * Runtime assertion support.  Don't enable this in production builds; it may
- * hurt performance significantly.
- */
-#ifdef LIBDEFLATE_ENABLE_ASSERTIONS
-NORETURN void
-libdeflate_assertion_failed(const char *expr, const char *file, int line);
-#define ASSERT(expr) { if (unlikely(!(expr))) \
-	libdeflate_assertion_failed(#expr, __FILE__, __LINE__); }
-#else
-#define ASSERT(expr) (void)(expr)
-#endif
-
-#define CONCAT_IMPL(a, b)	a##b
-#define CONCAT(a, b)		CONCAT_IMPL(a, b)
-#define ADD_SUFFIX(name)	CONCAT(name, SUFFIX)
-
-#endif /* LIB_LIB_COMMON_H */
diff --git a/vendor/core/vendor/libdeflate/lib/matchfinder_common.h b/vendor/core/vendor/libdeflate/lib/matchfinder_common.h
deleted file mode 100644
index 98e4bc71..00000000
--- a/vendor/core/vendor/libdeflate/lib/matchfinder_common.h
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- * matchfinder_common.h - common code for Lempel-Ziv matchfinding
- */
-
-#ifndef LIB_MATCHFINDER_COMMON_H
-#define LIB_MATCHFINDER_COMMON_H
-
-#include "lib_common.h"
-
-#ifndef MATCHFINDER_WINDOW_ORDER
-#  error "MATCHFINDER_WINDOW_ORDER must be defined!"
-#endif
-
-/*
- * Given a 32-bit value that was loaded with the platform's native endianness,
- * return a 32-bit value whose high-order 8 bits are 0 and whose low-order 24
- * bits contain the first 3 bytes, arranged in octets in a platform-dependent
- * order, at the memory location from which the input 32-bit value was loaded.
- */
-static forceinline u32
-loaded_u32_to_u24(u32 v)
-{
-	if (CPU_IS_LITTLE_ENDIAN())
-		return v & 0xFFFFFF;
-	else
-		return v >> 8;
-}
-
-/*
- * Load the next 3 bytes from @p into the 24 low-order bits of a 32-bit value.
- * The order in which the 3 bytes will be arranged as octets in the 24 bits is
- * platform-dependent.  At least 4 bytes (not 3) must be available at @p.
- */
-static forceinline u32
-load_u24_unaligned(const u8 *p)
-{
-#if UNALIGNED_ACCESS_IS_FAST
-	return loaded_u32_to_u24(load_u32_unaligned(p));
-#else
-	if (CPU_IS_LITTLE_ENDIAN())
-		return ((u32)p[0] << 0) | ((u32)p[1] << 8) | ((u32)p[2] << 16);
-	else
-		return ((u32)p[2] << 0) | ((u32)p[1] << 8) | ((u32)p[0] << 16);
-#endif
-}
-
-#define MATCHFINDER_WINDOW_SIZE (1UL << MATCHFINDER_WINDOW_ORDER)
-
-typedef s16 mf_pos_t;
-
-#define MATCHFINDER_INITVAL ((mf_pos_t)-MATCHFINDER_WINDOW_SIZE)
-
-/*
- * This is the memory address alignment, in bytes, required for the matchfinder
- * buffers by the architecture-specific implementations of matchfinder_init()
- * and matchfinder_rebase().  "Matchfinder buffer" means an entire struct
- * hc_matchfinder, bt_matchfinder, or ht_matchfinder; the next_tab field of
- * struct hc_matchfinder; or the child_tab field of struct bt_matchfinder.
- *
- * This affects how the entire 'struct deflate_compressor' is allocated, since
- * the matchfinder structures are embedded inside it.
- *
- * Currently the maximum memory address alignment required is 32 bytes, needed
- * by the AVX-2 matchfinder functions.
- */
-#define MATCHFINDER_MEM_ALIGNMENT	32
-
-/*
- * This declares a size, in bytes, that is guaranteed to divide the sizes of the
- * matchfinder buffers (where "matchfinder buffers" is as defined for
- * MATCHFINDER_MEM_ALIGNMENT).  The architecture-specific implementations of
- * matchfinder_init() and matchfinder_rebase() take advantage of this value.
- *
- * Currently the maximum size alignment required is 128 bytes, needed by
- * the AVX-2 matchfinder functions.  However, the RISC-V Vector Extension
- * matchfinder functions can, in principle, take advantage of a larger size
- * alignment.  Therefore, we set this to 1024, which still easily divides the
- * actual sizes that result from the current matchfinder struct definitions.
- * This value can safely be changed to any power of two that is >= 128.
- */
-#define MATCHFINDER_SIZE_ALIGNMENT	1024
-
-#undef matchfinder_init
-#undef matchfinder_rebase
-#ifdef _aligned_attribute
-#  define MATCHFINDER_ALIGNED _aligned_attribute(MATCHFINDER_MEM_ALIGNMENT)
-#  if defined(ARCH_ARM32) || defined(ARCH_ARM64)
-#    include "arm/matchfinder_impl.h"
-#  elif defined(ARCH_RISCV)
-#    include "riscv/matchfinder_impl.h"
-#  elif defined(ARCH_X86_32) || defined(ARCH_X86_64)
-#    include "x86/matchfinder_impl.h"
-#  endif
-#else
-#  define MATCHFINDER_ALIGNED
-#endif
-
-/*
- * Initialize the hash table portion of the matchfinder.
- *
- * Essentially, this is an optimized memset().
- *
- * 'data' must be aligned to a MATCHFINDER_MEM_ALIGNMENT boundary, and
- * 'size' must be a multiple of MATCHFINDER_SIZE_ALIGNMENT.
- */
-#ifndef matchfinder_init
-static forceinline void
-matchfinder_init(mf_pos_t *data, size_t size)
-{
-	size_t num_entries = size / sizeof(*data);
-	size_t i;
-
-	for (i = 0; i < num_entries; i++)
-		data[i] = MATCHFINDER_INITVAL;
-}
-#endif
-
-/*
- * Slide the matchfinder by MATCHFINDER_WINDOW_SIZE bytes.
- *
- * This must be called just after each MATCHFINDER_WINDOW_SIZE bytes have been
- * run through the matchfinder.
- *
- * This subtracts MATCHFINDER_WINDOW_SIZE bytes from each entry in the given
- * array, making the entries be relative to the current position rather than the
- * position MATCHFINDER_WINDOW_SIZE bytes prior.  To avoid integer underflows,
- * entries that would become less than -MATCHFINDER_WINDOW_SIZE stay at
- * -MATCHFINDER_WINDOW_SIZE, keeping them permanently out of bounds.
- *
- * The given array must contain all matchfinder data that is position-relative:
- * the hash table(s) as well as any hash chain or binary tree links.  Its
- * address must be aligned to a MATCHFINDER_MEM_ALIGNMENT boundary, and its size
- * must be a multiple of MATCHFINDER_SIZE_ALIGNMENT.
- */
-#ifndef matchfinder_rebase
-static forceinline void
-matchfinder_rebase(mf_pos_t *data, size_t size)
-{
-	size_t num_entries = size / sizeof(*data);
-	size_t i;
-
-	if (MATCHFINDER_WINDOW_SIZE == 32768) {
-		/*
-		 * Branchless version for 32768-byte windows.  Clear all bits if
-		 * the value was already negative, then set the sign bit.  This
-		 * is equivalent to subtracting 32768 with signed saturation.
-		 */
-		for (i = 0; i < num_entries; i++)
-			data[i] = 0x8000 | (data[i] & ~(data[i] >> 15));
-	} else {
-		for (i = 0; i < num_entries; i++) {
-			if (data[i] >= 0)
-				data[i] -= (mf_pos_t)-MATCHFINDER_WINDOW_SIZE;
-			else
-				data[i] = (mf_pos_t)-MATCHFINDER_WINDOW_SIZE;
-		}
-	}
-}
-#endif
-
-/*
- * The hash function: given a sequence prefix held in the low-order bits of a
- * 32-bit value, multiply by a carefully-chosen large constant.  Discard any
- * bits of the product that don't fit in a 32-bit value, but take the
- * next-highest @num_bits bits of the product as the hash value, as those have
- * the most randomness.
- */
-static forceinline u32
-lz_hash(u32 seq, unsigned num_bits)
-{
-	return (u32)(seq * 0x1E35A7BD) >> (32 - num_bits);
-}
-
-/*
- * Return the number of bytes at @matchptr that match the bytes at @strptr, up
- * to a maximum of @max_len.  Initially, @start_len bytes are matched.
- */
-static forceinline u32
-lz_extend(const u8 * const strptr, const u8 * const matchptr,
-	  const u32 start_len, const u32 max_len)
-{
-	u32 len = start_len;
-	machine_word_t v_word;
-
-	if (UNALIGNED_ACCESS_IS_FAST) {
-
-		if (likely(max_len - len >= 4 * WORDBYTES)) {
-
-		#define COMPARE_WORD_STEP				\
-			v_word = load_word_unaligned(&matchptr[len]) ^	\
-				 load_word_unaligned(&strptr[len]);	\
-			if (v_word != 0)				\
-				goto word_differs;			\
-			len += WORDBYTES;				\
-
-			COMPARE_WORD_STEP
-			COMPARE_WORD_STEP
-			COMPARE_WORD_STEP
-			COMPARE_WORD_STEP
-		#undef COMPARE_WORD_STEP
-		}
-
-		while (len + WORDBYTES <= max_len) {
-			v_word = load_word_unaligned(&matchptr[len]) ^
-				 load_word_unaligned(&strptr[len]);
-			if (v_word != 0)
-				goto word_differs;
-			len += WORDBYTES;
-		}
-	}
-
-	while (len < max_len && matchptr[len] == strptr[len])
-		len++;
-	return len;
-
-word_differs:
-	if (CPU_IS_LITTLE_ENDIAN())
-		len += (bsfw(v_word) >> 3);
-	else
-		len += (WORDBITS - 1 - bsrw(v_word)) >> 3;
-	return len;
-}
-
-#endif /* LIB_MATCHFINDER_COMMON_H */
diff --git a/vendor/core/vendor/libdeflate/lib/riscv/matchfinder_impl.h b/vendor/core/vendor/libdeflate/lib/riscv/matchfinder_impl.h
deleted file mode 100644
index 6d8bf793..00000000
--- a/vendor/core/vendor/libdeflate/lib/riscv/matchfinder_impl.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * riscv/matchfinder_impl.h - RISC-V implementations of matchfinder functions
- *
- * Copyright 2024 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_RISCV_MATCHFINDER_IMPL_H
-#define LIB_RISCV_MATCHFINDER_IMPL_H
-
-#if defined(ARCH_RISCV) && defined(__riscv_vector)
-#include <riscv_vector.h>
-
-/*
- * Return the maximum number of 16-bit (mf_pos_t) elements that fit in 8 RISC-V
- * vector registers and also evenly divide the sizes of the matchfinder buffers.
- */
-static forceinline size_t
-riscv_matchfinder_vl(void)
-{
-	const size_t vl = __riscv_vsetvlmax_e16m8();
-
-	STATIC_ASSERT(sizeof(mf_pos_t) == sizeof(s16));
-	/*
-	 * MATCHFINDER_SIZE_ALIGNMENT is a power of 2, as is 'vl' because the
-	 * RISC-V Vector Extension requires that the vector register length
-	 * (VLEN) be a power of 2.  Thus, a simple MIN() gives the correct
-	 * answer here; rounding to a power of 2 is not required.
-	 */
-	STATIC_ASSERT((MATCHFINDER_SIZE_ALIGNMENT &
-		       (MATCHFINDER_SIZE_ALIGNMENT - 1)) == 0);
-	ASSERT((vl & (vl - 1)) == 0);
-	return MIN(vl, MATCHFINDER_SIZE_ALIGNMENT / sizeof(mf_pos_t));
-}
-
-/* matchfinder_init() optimized using the RISC-V Vector Extension */
-static forceinline void
-matchfinder_init_rvv(mf_pos_t *p, size_t size)
-{
-	const size_t vl = riscv_matchfinder_vl();
-	const vint16m8_t v = __riscv_vmv_v_x_i16m8(MATCHFINDER_INITVAL, vl);
-
-	ASSERT(size > 0 && size % (vl * sizeof(p[0])) == 0);
-	do {
-		__riscv_vse16_v_i16m8(p, v, vl);
-		p += vl;
-		size -= vl * sizeof(p[0]);
-	} while (size != 0);
-}
-#define matchfinder_init matchfinder_init_rvv
-
-/* matchfinder_rebase() optimized using the RISC-V Vector Extension */
-static forceinline void
-matchfinder_rebase_rvv(mf_pos_t *p, size_t size)
-{
-	const size_t vl = riscv_matchfinder_vl();
-
-	ASSERT(size > 0 && size % (vl * sizeof(p[0])) == 0);
-	do {
-		vint16m8_t v = __riscv_vle16_v_i16m8(p, vl);
-
-		/*
-		 * This should generate the vsadd.vx instruction
-		 * (Vector Saturating Add, integer vector-scalar)
-		 */
-		v = __riscv_vsadd_vx_i16m8(v, (s16)-MATCHFINDER_WINDOW_SIZE,
-					   vl);
-		__riscv_vse16_v_i16m8(p, v, vl);
-		p += vl;
-		size -= vl * sizeof(p[0]);
-	} while (size != 0);
-}
-#define matchfinder_rebase matchfinder_rebase_rvv
-
-#endif /* ARCH_RISCV && __riscv_vector */
-
-#endif /* LIB_RISCV_MATCHFINDER_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/utils.c b/vendor/core/vendor/libdeflate/lib/utils.c
deleted file mode 100644
index 5bb34eda..00000000
--- a/vendor/core/vendor/libdeflate/lib/utils.c
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * utils.c - utility functions for libdeflate
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "lib_common.h"
-
-#ifdef FREESTANDING
-#  define malloc NULL
-#  define free NULL
-#else
-#  include <stdlib.h>
-#endif
-
-malloc_func_t libdeflate_default_malloc_func = malloc;
-free_func_t libdeflate_default_free_func = free;
-
-void *
-libdeflate_aligned_malloc(malloc_func_t malloc_func,
-			  size_t alignment, size_t size)
-{
-	void *ptr = (*malloc_func)(sizeof(void *) + alignment - 1 + size);
-
-	if (ptr) {
-		void *orig_ptr = ptr;
-
-		ptr = (void *)ALIGN((uintptr_t)ptr + sizeof(void *), alignment);
-		((void **)ptr)[-1] = orig_ptr;
-	}
-	return ptr;
-}
-
-void
-libdeflate_aligned_free(free_func_t free_func, void *ptr)
-{
-	(*free_func)(((void **)ptr)[-1]);
-}
-
-LIBDEFLATEAPI void
-libdeflate_set_memory_allocator(malloc_func_t malloc_func,
-				free_func_t free_func)
-{
-	libdeflate_default_malloc_func = malloc_func;
-	libdeflate_default_free_func = free_func;
-}
-
-/*
- * Implementations of libc functions for freestanding library builds.
- * Normal library builds don't use these.  Not optimized yet; usually the
- * compiler expands these functions and doesn't actually call them anyway.
- */
-#ifdef FREESTANDING
-#undef memset
-void * __attribute__((weak))
-memset(void *s, int c, size_t n)
-{
-	u8 *p = s;
-	size_t i;
-
-	for (i = 0; i < n; i++)
-		p[i] = c;
-	return s;
-}
-
-#undef memcpy
-void * __attribute__((weak))
-memcpy(void *dest, const void *src, size_t n)
-{
-	u8 *d = dest;
-	const u8 *s = src;
-	size_t i;
-
-	for (i = 0; i < n; i++)
-		d[i] = s[i];
-	return dest;
-}
-
-#undef memmove
-void * __attribute__((weak))
-memmove(void *dest, const void *src, size_t n)
-{
-	u8 *d = dest;
-	const u8 *s = src;
-	size_t i;
-
-	if (d <= s)
-		return memcpy(d, s, n);
-
-	for (i = n; i > 0; i--)
-		d[i - 1] = s[i - 1];
-	return dest;
-}
-
-#undef memcmp
-int __attribute__((weak))
-memcmp(const void *s1, const void *s2, size_t n)
-{
-	const u8 *p1 = s1;
-	const u8 *p2 = s2;
-	size_t i;
-
-	for (i = 0; i < n; i++) {
-		if (p1[i] != p2[i])
-			return (int)p1[i] - (int)p2[i];
-	}
-	return 0;
-}
-#endif /* FREESTANDING */
-
-#ifdef LIBDEFLATE_ENABLE_ASSERTIONS
-#include <stdio.h>
-#include <stdlib.h>
-NORETURN void
-libdeflate_assertion_failed(const char *expr, const char *file, int line)
-{
-	fprintf(stderr, "Assertion failed: %s at %s:%d\n", expr, file, line);
-	abort();
-}
-#endif /* LIBDEFLATE_ENABLE_ASSERTIONS */
diff --git a/vendor/core/vendor/libdeflate/lib/x86/adler32_impl.h b/vendor/core/vendor/libdeflate/lib/x86/adler32_impl.h
deleted file mode 100644
index f1102b5e..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/adler32_impl.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * x86/adler32_impl.h - x86 implementations of Adler-32 checksum algorithm
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_X86_ADLER32_IMPL_H
-#define LIB_X86_ADLER32_IMPL_H
-
-#include "cpu_features.h"
-
-/* SSE2 and AVX2 implementations.  Used on older CPUs. */
-#if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)
-#  define adler32_x86_sse2	adler32_x86_sse2
-#  define SUFFIX			   _sse2
-#  define ATTRIBUTES		_target_attribute("sse2")
-#  define VL			16
-#  define USE_VNNI		0
-#  define USE_AVX512		0
-#  include "adler32_template.h"
-
-#  define adler32_x86_avx2	adler32_x86_avx2
-#  define SUFFIX			   _avx2
-#  define ATTRIBUTES		_target_attribute("avx2")
-#  define VL			32
-#  define USE_VNNI		0
-#  define USE_AVX512		0
-#  include "adler32_template.h"
-#endif
-
-/*
- * AVX-VNNI implementation.  This is used on CPUs that have AVX2 and AVX-VNNI
- * but don't have AVX-512, for example Intel Alder Lake.
- *
- * Unusually for a new CPU feature, gcc added support for the AVX-VNNI
- * intrinsics (in gcc 11.1) slightly before binutils added support for
- * assembling AVX-VNNI instructions (in binutils 2.36).  Distros can reasonably
- * have gcc 11 with binutils 2.35.  Because of this issue, we check for gcc 12
- * instead of gcc 11.  (libdeflate supports direct compilation without a
- * configure step, so checking the binutils version is not always an option.)
- */
-#if (GCC_PREREQ(12, 1) || CLANG_PREREQ(12, 0, 13000000) || MSVC_PREREQ(1930)) && \
-	!defined(LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_AVX_VNNI)
-#  define adler32_x86_avx2_vnni	adler32_x86_avx2_vnni
-#  define SUFFIX			   _avx2_vnni
-#  define ATTRIBUTES		_target_attribute("avx2,avxvnni")
-#  define VL			32
-#  define USE_VNNI		1
-#  define USE_AVX512		0
-#  include "adler32_template.h"
-#endif
-
-#if (GCC_PREREQ(8, 1) || CLANG_PREREQ(6, 0, 10000000) || MSVC_PREREQ(1920)) && \
-	!(CLANG_PREREQ(18, 0, 18000000) && !CLANG_PREREQ(19, 0, 19000000)) && \
-	!defined(LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_AVX512VNNI)
-/*
- * AVX512VNNI implementation using 256-bit vectors.  This is very similar to the
- * AVX-VNNI implementation but takes advantage of masking and more registers.
- * This is used on certain older Intel CPUs, specifically Ice Lake and Tiger
- * Lake, which support AVX512VNNI but downclock a bit too eagerly when ZMM
- * registers are used.
- */
-#  define adler32_x86_avx512_vl256_vnni	adler32_x86_avx512_vl256_vnni
-#  define SUFFIX				   _avx512_vl256_vnni
-#  define ATTRIBUTES		_target_attribute("avx512bw,avx512vl,avx512vnni")
-#  define VL			32
-#  define USE_VNNI		1
-#  define USE_AVX512		1
-#  include "adler32_template.h"
-
-/*
- * AVX512VNNI implementation using 512-bit vectors.  This is used on CPUs that
- * have a good AVX-512 implementation including AVX512VNNI.
- */
-#  define adler32_x86_avx512_vl512_vnni	adler32_x86_avx512_vl512_vnni
-#  define SUFFIX				   _avx512_vl512_vnni
-#  define ATTRIBUTES		_target_attribute("avx512bw,avx512vnni")
-#  define VL			64
-#  define USE_VNNI		1
-#  define USE_AVX512		1
-#  include "adler32_template.h"
-#endif
-
-static inline adler32_func_t
-arch_select_adler32_func(void)
-{
-	const u32 features MAYBE_UNUSED = get_x86_cpu_features();
-
-#ifdef adler32_x86_avx512_vl512_vnni
-	if ((features & X86_CPU_FEATURE_ZMM) &&
-	    HAVE_AVX512BW(features) && HAVE_AVX512VNNI(features))
-		return adler32_x86_avx512_vl512_vnni;
-#endif
-#ifdef adler32_x86_avx512_vl256_vnni
-	if (HAVE_AVX512BW(features) && HAVE_AVX512VL(features) &&
-	    HAVE_AVX512VNNI(features))
-		return adler32_x86_avx512_vl256_vnni;
-#endif
-#ifdef adler32_x86_avx2_vnni
-	if (HAVE_AVX2(features) && HAVE_AVXVNNI(features))
-		return adler32_x86_avx2_vnni;
-#endif
-#ifdef adler32_x86_avx2
-	if (HAVE_AVX2(features))
-		return adler32_x86_avx2;
-#endif
-#ifdef adler32_x86_sse2
-	if (HAVE_SSE2(features))
-		return adler32_x86_sse2;
-#endif
-	return NULL;
-}
-#define arch_select_adler32_func	arch_select_adler32_func
-
-#endif /* LIB_X86_ADLER32_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/x86/adler32_template.h b/vendor/core/vendor/libdeflate/lib/x86/adler32_template.h
deleted file mode 100644
index 1593ee5a..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/adler32_template.h
+++ /dev/null
@@ -1,518 +0,0 @@
-/*
- * x86/adler32_template.h - template for vectorized Adler-32 implementations
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-/*
- * This file is a "template" for instantiating Adler-32 functions for x86.
- * The "parameters" are:
- *
- * SUFFIX:
- *	Name suffix to append to all instantiated functions.
- * ATTRIBUTES:
- *	Target function attributes to use.  Must satisfy the dependencies of the
- *	other parameters as follows:
- *	   VL=16 && USE_VNNI=0 && USE_AVX512=0: at least sse2
- *	   VL=32 && USE_VNNI=0 && USE_AVX512=0: at least avx2
- *	   VL=32 && USE_VNNI=1 && USE_AVX512=0: at least avx2,avxvnni
- *	   VL=32 && USE_VNNI=1 && USE_AVX512=1: at least avx512bw,avx512vl,avx512vnni
- *	   VL=64 && USE_VNNI=1 && USE_AVX512=1: at least avx512bw,avx512vnni
- *	   (Other combinations are not useful and have not been tested.)
- * VL:
- *	Vector length in bytes.  Must be 16, 32, or 64.
- * USE_VNNI:
- *	If 1, use the VNNI dot product based algorithm.
- *	If 0, use the legacy SSE2 and AVX2 compatible algorithm.
- * USE_AVX512:
- *	If 1, take advantage of AVX-512 features such as masking.  This doesn't
- *	enable the use of 512-bit vectors; the vector length is controlled by
- *	VL.  If 0, assume that the CPU might not support AVX-512.
- */
-
-#if VL == 16
-#  define vec_t			__m128i
-#  define mask_t		u16
-#  define LOG2_VL		4
-#  define VADD8(a, b)		_mm_add_epi8((a), (b))
-#  define VADD16(a, b)		_mm_add_epi16((a), (b))
-#  define VADD32(a, b)		_mm_add_epi32((a), (b))
-#  if USE_AVX512
-#    define VDPBUSD(a, b, c)	_mm_dpbusd_epi32((a), (b), (c))
-#  else
-#    define VDPBUSD(a, b, c)	_mm_dpbusd_avx_epi32((a), (b), (c))
-#  endif
-#  define VLOAD(p)		_mm_load_si128((const void *)(p))
-#  define VLOADU(p)		_mm_loadu_si128((const void *)(p))
-#  define VMADD16(a, b)		_mm_madd_epi16((a), (b))
-#  define VMASKZ_LOADU(mask, p) _mm_maskz_loadu_epi8((mask), (p))
-#  define VMULLO32(a, b)	_mm_mullo_epi32((a), (b))
-#  define VSAD8(a, b)		_mm_sad_epu8((a), (b))
-#  define VSET1_8(a)		_mm_set1_epi8(a)
-#  define VSET1_32(a)		_mm_set1_epi32(a)
-#  define VSETZERO()		_mm_setzero_si128()
-#  define VSLL32(a, b)		_mm_slli_epi32((a), (b))
-#  define VUNPACKLO8(a, b)	_mm_unpacklo_epi8((a), (b))
-#  define VUNPACKHI8(a, b)	_mm_unpackhi_epi8((a), (b))
-#elif VL == 32
-#  define vec_t			__m256i
-#  define mask_t		u32
-#  define LOG2_VL		5
-#  define VADD8(a, b)		_mm256_add_epi8((a), (b))
-#  define VADD16(a, b)		_mm256_add_epi16((a), (b))
-#  define VADD32(a, b)		_mm256_add_epi32((a), (b))
-#  if USE_AVX512
-#    define VDPBUSD(a, b, c)	_mm256_dpbusd_epi32((a), (b), (c))
-#  else
-#    define VDPBUSD(a, b, c)	_mm256_dpbusd_avx_epi32((a), (b), (c))
-#  endif
-#  define VLOAD(p)		_mm256_load_si256((const void *)(p))
-#  define VLOADU(p)		_mm256_loadu_si256((const void *)(p))
-#  define VMADD16(a, b)		_mm256_madd_epi16((a), (b))
-#  define VMASKZ_LOADU(mask, p) _mm256_maskz_loadu_epi8((mask), (p))
-#  define VMULLO32(a, b)	_mm256_mullo_epi32((a), (b))
-#  define VSAD8(a, b)		_mm256_sad_epu8((a), (b))
-#  define VSET1_8(a)		_mm256_set1_epi8(a)
-#  define VSET1_32(a)		_mm256_set1_epi32(a)
-#  define VSETZERO()		_mm256_setzero_si256()
-#  define VSLL32(a, b)		_mm256_slli_epi32((a), (b))
-#  define VUNPACKLO8(a, b)	_mm256_unpacklo_epi8((a), (b))
-#  define VUNPACKHI8(a, b)	_mm256_unpackhi_epi8((a), (b))
-#elif VL == 64
-#  define vec_t			__m512i
-#  define mask_t		u64
-#  define LOG2_VL		6
-#  define VADD8(a, b)		_mm512_add_epi8((a), (b))
-#  define VADD16(a, b)		_mm512_add_epi16((a), (b))
-#  define VADD32(a, b)		_mm512_add_epi32((a), (b))
-#  define VDPBUSD(a, b, c)	_mm512_dpbusd_epi32((a), (b), (c))
-#  define VLOAD(p)		_mm512_load_si512((const void *)(p))
-#  define VLOADU(p)		_mm512_loadu_si512((const void *)(p))
-#  define VMADD16(a, b)		_mm512_madd_epi16((a), (b))
-#  define VMASKZ_LOADU(mask, p) _mm512_maskz_loadu_epi8((mask), (p))
-#  define VMULLO32(a, b)	_mm512_mullo_epi32((a), (b))
-#  define VSAD8(a, b)		_mm512_sad_epu8((a), (b))
-#  define VSET1_8(a)		_mm512_set1_epi8(a)
-#  define VSET1_32(a)		_mm512_set1_epi32(a)
-#  define VSETZERO()		_mm512_setzero_si512()
-#  define VSLL32(a, b)		_mm512_slli_epi32((a), (b))
-#  define VUNPACKLO8(a, b)	_mm512_unpacklo_epi8((a), (b))
-#  define VUNPACKHI8(a, b)	_mm512_unpackhi_epi8((a), (b))
-#else
-#  error "unsupported vector length"
-#endif
-
-#define VADD32_3X(a, b, c)	VADD32(VADD32((a), (b)), (c))
-#define VADD32_4X(a, b, c, d)	VADD32(VADD32((a), (b)), VADD32((c), (d)))
-#define VADD32_5X(a, b, c, d, e) VADD32((a), VADD32_4X((b), (c), (d), (e)))
-#define VADD32_7X(a, b, c, d, e, f, g)	\
-	VADD32(VADD32_3X((a), (b), (c)), VADD32_4X((d), (e), (f), (g)))
-
-/* Sum the 32-bit elements of v_s1 and add them to s1, and likewise for s2. */
-#undef reduce_to_32bits
-static forceinline ATTRIBUTES void
-ADD_SUFFIX(reduce_to_32bits)(vec_t v_s1, vec_t v_s2, u32 *s1_p, u32 *s2_p)
-{
-	__m128i v_s1_128, v_s2_128;
-#if VL == 16
-	{
-		v_s1_128 = v_s1;
-		v_s2_128 = v_s2;
-	}
-#else
-	{
-		__m256i v_s1_256, v_s2_256;
-	#if VL == 32
-		v_s1_256 = v_s1;
-		v_s2_256 = v_s2;
-	#else
-		/* Reduce 512 bits to 256 bits. */
-		v_s1_256 = _mm256_add_epi32(_mm512_extracti64x4_epi64(v_s1, 0),
-					    _mm512_extracti64x4_epi64(v_s1, 1));
-		v_s2_256 = _mm256_add_epi32(_mm512_extracti64x4_epi64(v_s2, 0),
-					    _mm512_extracti64x4_epi64(v_s2, 1));
-	#endif
-		/* Reduce 256 bits to 128 bits. */
-		v_s1_128 = _mm_add_epi32(_mm256_extracti128_si256(v_s1_256, 0),
-					 _mm256_extracti128_si256(v_s1_256, 1));
-		v_s2_128 = _mm_add_epi32(_mm256_extracti128_si256(v_s2_256, 0),
-					 _mm256_extracti128_si256(v_s2_256, 1));
-	}
-#endif
-
-	/*
-	 * Reduce 128 bits to 32 bits.
-	 *
-	 * If the bytes were summed into v_s1 using psadbw + paddd, then ignore
-	 * the odd-indexed elements of v_s1_128 since they are zero.
-	 */
-#if USE_VNNI
-	v_s1_128 = _mm_add_epi32(v_s1_128, _mm_shuffle_epi32(v_s1_128, 0x31));
-#endif
-	v_s2_128 = _mm_add_epi32(v_s2_128, _mm_shuffle_epi32(v_s2_128, 0x31));
-	v_s1_128 = _mm_add_epi32(v_s1_128, _mm_shuffle_epi32(v_s1_128, 0x02));
-	v_s2_128 = _mm_add_epi32(v_s2_128, _mm_shuffle_epi32(v_s2_128, 0x02));
-
-	*s1_p += (u32)_mm_cvtsi128_si32(v_s1_128);
-	*s2_p += (u32)_mm_cvtsi128_si32(v_s2_128);
-}
-#define reduce_to_32bits	ADD_SUFFIX(reduce_to_32bits)
-
-static ATTRIBUTES u32
-ADD_SUFFIX(adler32_x86)(u32 adler, const u8 *p, size_t len)
-{
-#if USE_VNNI
-	/* This contains the bytes [VL, VL-1, VL-2, ..., 1]. */
-	static const u8 _aligned_attribute(VL) raw_mults[VL] = {
-	#if VL == 64
-		64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49,
-		48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
-	#endif
-	#if VL >= 32
-		32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
-	#endif
-		16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,
-	};
-	const vec_t ones = VSET1_8(1);
-#else
-	/*
-	 * This contains the 16-bit values [2*VL, 2*VL - 1, 2*VL - 2, ..., 1].
-	 * For VL==32 the ordering is weird because it has to match the way that
-	 * vpunpcklbw and vpunpckhbw work on 128-bit lanes separately.
-	 */
-	static const u16 _aligned_attribute(VL) raw_mults[4][VL / 2] = {
-	#if VL == 16
-		{ 32, 31, 30, 29, 28, 27, 26, 25 },
-		{ 24, 23, 22, 21, 20, 19, 18, 17 },
-		{ 16, 15, 14, 13, 12, 11, 10, 9  },
-		{ 8,  7,  6,  5,  4,  3,  2,  1  },
-	#elif VL == 32
-		{ 64, 63, 62, 61, 60, 59, 58, 57, 48, 47, 46, 45, 44, 43, 42, 41 },
-		{ 56, 55, 54, 53, 52, 51, 50, 49, 40, 39, 38, 37, 36, 35, 34, 33 },
-		{ 32, 31, 30, 29, 28, 27, 26, 25, 16, 15, 14, 13, 12, 11, 10,  9 },
-		{ 24, 23, 22, 21, 20, 19, 18, 17,  8,  7,  6,  5,  4,  3,  2,  1 },
-	#else
-	#  error "unsupported parameters"
-	#endif
-	};
-	const vec_t mults_a = VLOAD(raw_mults[0]);
-	const vec_t mults_b = VLOAD(raw_mults[1]);
-	const vec_t mults_c = VLOAD(raw_mults[2]);
-	const vec_t mults_d = VLOAD(raw_mults[3]);
-#endif
-	const vec_t zeroes = VSETZERO();
-	u32 s1 = adler & 0xFFFF;
-	u32 s2 = adler >> 16;
-
-	/*
-	 * If the length is large and the pointer is misaligned, align it.
-	 * For smaller lengths, just take the misaligned load penalty.
-	 */
-	if (unlikely(len > 65536 && ((uintptr_t)p & (VL-1)))) {
-		do {
-			s1 += *p++;
-			s2 += s1;
-			len--;
-		} while ((uintptr_t)p & (VL-1));
-		s1 %= DIVISOR;
-		s2 %= DIVISOR;
-	}
-
-#if USE_VNNI
-	/*
-	 * This is Adler-32 using the vpdpbusd instruction from AVX512VNNI or
-	 * AVX-VNNI.  vpdpbusd multiplies the unsigned bytes of one vector by
-	 * the signed bytes of another vector and adds the sums in groups of 4
-	 * to the 32-bit elements of a third vector.  We use it in two ways:
-	 * multiplying the data bytes by a sequence like 64,63,62,...,1 for
-	 * calculating part of s2, and multiplying the data bytes by an all-ones
-	 * sequence 1,1,1,...,1 for calculating s1 and part of s2.  The all-ones
-	 * trick seems to be faster than the alternative of vpsadbw + vpaddd.
-	 */
-	while (len) {
-		/*
-		 * Calculate the length of the next data chunk such that s1 and
-		 * s2 are guaranteed to not exceed UINT32_MAX.
-		 */
-		size_t n = MIN(len, MAX_CHUNK_LEN & ~(4*VL - 1));
-		vec_t mults = VLOAD(raw_mults);
-		vec_t v_s1 = zeroes;
-		vec_t v_s2 = zeroes;
-
-		s2 += s1 * n;
-		len -= n;
-
-		if (n >= 4*VL) {
-			vec_t v_s1_b = zeroes;
-			vec_t v_s1_c = zeroes;
-			vec_t v_s1_d = zeroes;
-			vec_t v_s2_b = zeroes;
-			vec_t v_s2_c = zeroes;
-			vec_t v_s2_d = zeroes;
-			vec_t v_s1_sums   = zeroes;
-			vec_t v_s1_sums_b = zeroes;
-			vec_t v_s1_sums_c = zeroes;
-			vec_t v_s1_sums_d = zeroes;
-			vec_t tmp0, tmp1;
-
-			do {
-				vec_t data_a = VLOADU(p + 0*VL);
-				vec_t data_b = VLOADU(p + 1*VL);
-				vec_t data_c = VLOADU(p + 2*VL);
-				vec_t data_d = VLOADU(p + 3*VL);
-
-				/*
-				 * Workaround for gcc bug where it generates
-				 * unnecessary move instructions
-				 * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107892)
-				 */
-			#if GCC_PREREQ(1, 0)
-				__asm__("" : "+v" (data_a), "+v" (data_b),
-					     "+v" (data_c), "+v" (data_d));
-			#endif
-
-				v_s2   = VDPBUSD(v_s2,   data_a, mults);
-				v_s2_b = VDPBUSD(v_s2_b, data_b, mults);
-				v_s2_c = VDPBUSD(v_s2_c, data_c, mults);
-				v_s2_d = VDPBUSD(v_s2_d, data_d, mults);
-
-				v_s1_sums   = VADD32(v_s1_sums,   v_s1);
-				v_s1_sums_b = VADD32(v_s1_sums_b, v_s1_b);
-				v_s1_sums_c = VADD32(v_s1_sums_c, v_s1_c);
-				v_s1_sums_d = VADD32(v_s1_sums_d, v_s1_d);
-
-				v_s1   = VDPBUSD(v_s1,   data_a, ones);
-				v_s1_b = VDPBUSD(v_s1_b, data_b, ones);
-				v_s1_c = VDPBUSD(v_s1_c, data_c, ones);
-				v_s1_d = VDPBUSD(v_s1_d, data_d, ones);
-
-				/* Same gcc bug workaround.  See above */
-			#if GCC_PREREQ(1, 0) && !defined(ARCH_X86_32)
-				__asm__("" : "+v" (v_s2), "+v" (v_s2_b),
-					     "+v" (v_s2_c), "+v" (v_s2_d),
-					     "+v" (v_s1_sums),
-					     "+v" (v_s1_sums_b),
-					     "+v" (v_s1_sums_c),
-					     "+v" (v_s1_sums_d),
-					     "+v" (v_s1), "+v" (v_s1_b),
-					     "+v" (v_s1_c), "+v" (v_s1_d));
-			#endif
-				p += 4*VL;
-				n -= 4*VL;
-			} while (n >= 4*VL);
-
-			/*
-			 * Reduce into v_s1 and v_s2 as follows:
-			 *
-			 * v_s2 = v_s2 + v_s2_b + v_s2_c + v_s2_d +
-			 *	  (4*VL)*(v_s1_sums   + v_s1_sums_b +
-			 *		  v_s1_sums_c + v_s1_sums_d) +
-			 *	  (3*VL)*v_s1 + (2*VL)*v_s1_b + VL*v_s1_c
-			 * v_s1 = v_s1 + v_s1_b + v_s1_c + v_s1_d
-			 */
-			tmp0 = VADD32(v_s1, v_s1_b);
-			tmp1 = VADD32(v_s1, v_s1_c);
-			v_s1_sums = VADD32_4X(v_s1_sums, v_s1_sums_b,
-					      v_s1_sums_c, v_s1_sums_d);
-			v_s1 = VADD32_3X(tmp0, v_s1_c, v_s1_d);
-			v_s2 = VADD32_7X(VSLL32(v_s1_sums, LOG2_VL + 2),
-					 VSLL32(tmp0, LOG2_VL + 1),
-					 VSLL32(tmp1, LOG2_VL),
-					 v_s2, v_s2_b, v_s2_c, v_s2_d);
-		}
-
-		/* Process the last 0 <= n < 4*VL bytes of the chunk. */
-		if (n >= 2*VL) {
-			const vec_t data_a = VLOADU(p + 0*VL);
-			const vec_t data_b = VLOADU(p + 1*VL);
-
-			v_s2 = VADD32(v_s2, VSLL32(v_s1, LOG2_VL + 1));
-			v_s1 = VDPBUSD(v_s1, data_a, ones);
-			v_s1 = VDPBUSD(v_s1, data_b, ones);
-			v_s2 = VDPBUSD(v_s2, data_a, VSET1_8(VL));
-			v_s2 = VDPBUSD(v_s2, data_a, mults);
-			v_s2 = VDPBUSD(v_s2, data_b, mults);
-			p += 2*VL;
-			n -= 2*VL;
-		}
-		if (n) {
-			/* Process the last 0 < n < 2*VL bytes of the chunk. */
-			vec_t data;
-
-			v_s2 = VADD32(v_s2, VMULLO32(v_s1, VSET1_32(n)));
-
-			mults = VADD8(mults, VSET1_8((int)n - VL));
-			if (n > VL) {
-				data = VLOADU(p);
-				v_s1 = VDPBUSD(v_s1, data, ones);
-				v_s2 = VDPBUSD(v_s2, data, mults);
-				p += VL;
-				n -= VL;
-				mults = VADD8(mults, VSET1_8(-VL));
-			}
-			/*
-			 * Process the last 0 < n <= VL bytes of the chunk.
-			 * Utilize a masked load if it's available.
-			 */
-		#if USE_AVX512
-			data = VMASKZ_LOADU((mask_t)-1 >> (VL - n), p);
-		#else
-			data = zeroes;
-			memcpy(&data, p, n);
-		#endif
-			v_s1 = VDPBUSD(v_s1, data, ones);
-			v_s2 = VDPBUSD(v_s2, data, mults);
-			p += n;
-		}
-
-		reduce_to_32bits(v_s1, v_s2, &s1, &s2);
-		s1 %= DIVISOR;
-		s2 %= DIVISOR;
-	}
-#else /* USE_VNNI */
-	/*
-	 * This is Adler-32 for SSE2 and AVX2.
-	 *
-	 * To horizontally sum bytes, use psadbw + paddd, where one of the
-	 * arguments to psadbw is all-zeroes.
-	 *
-	 * For the s2 contribution from (2*VL - i)*data[i] for each of the 2*VL
-	 * bytes of each iteration of the inner loop, use punpck{l,h}bw + paddw
-	 * to sum, for each i across iterations, byte i into a corresponding
-	 * 16-bit counter in v_byte_sums_*.  After the inner loop, use pmaddwd
-	 * to multiply each counter by (2*VL - i), then add the products to s2.
-	 *
-	 * An alternative implementation would use pmaddubsw and pmaddwd in the
-	 * inner loop to do (2*VL - i)*data[i] directly and add the products in
-	 * groups of 4 to 32-bit counters.  However, on average that approach
-	 * seems to be slower than the current approach which delays the
-	 * multiplications.  Also, pmaddubsw requires SSSE3; the current
-	 * approach keeps the implementation aligned between SSE2 and AVX2.
-	 *
-	 * The inner loop processes 2*VL bytes per iteration.  Increasing this
-	 * to 4*VL doesn't seem to be helpful here.
-	 */
-	while (len) {
-		/*
-		 * Calculate the length of the next data chunk such that s1 and
-		 * s2 are guaranteed to not exceed UINT32_MAX, and every
-		 * v_byte_sums_* counter is guaranteed to not exceed INT16_MAX.
-		 * It's INT16_MAX, not UINT16_MAX, because v_byte_sums_* are
-		 * used with pmaddwd which does signed multiplication.  In the
-		 * SSE2 case this limits chunks to 4096 bytes instead of 5536.
-		 */
-		size_t n = MIN(len, MIN(2 * VL * (INT16_MAX / UINT8_MAX),
-					MAX_CHUNK_LEN) & ~(2*VL - 1));
-		len -= n;
-
-		if (n >= 2*VL) {
-			vec_t v_s1 = zeroes;
-			vec_t v_s1_sums = zeroes;
-			vec_t v_byte_sums_a = zeroes;
-			vec_t v_byte_sums_b = zeroes;
-			vec_t v_byte_sums_c = zeroes;
-			vec_t v_byte_sums_d = zeroes;
-			vec_t v_s2;
-
-			s2 += s1 * (n & ~(2*VL - 1));
-
-			do {
-				vec_t data_a = VLOADU(p + 0*VL);
-				vec_t data_b = VLOADU(p + 1*VL);
-
-				v_s1_sums = VADD32(v_s1_sums, v_s1);
-				v_byte_sums_a = VADD16(v_byte_sums_a,
-						       VUNPACKLO8(data_a, zeroes));
-				v_byte_sums_b = VADD16(v_byte_sums_b,
-						       VUNPACKHI8(data_a, zeroes));
-				v_byte_sums_c = VADD16(v_byte_sums_c,
-						       VUNPACKLO8(data_b, zeroes));
-				v_byte_sums_d = VADD16(v_byte_sums_d,
-						       VUNPACKHI8(data_b, zeroes));
-				v_s1 = VADD32(v_s1,
-					      VADD32(VSAD8(data_a, zeroes),
-						     VSAD8(data_b, zeroes)));
-				/*
-				 * Workaround for gcc bug where it generates
-				 * unnecessary move instructions
-				 * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107892)
-				 */
-			#if GCC_PREREQ(1, 0)
-				__asm__("" : "+x" (v_s1), "+x" (v_s1_sums),
-					     "+x" (v_byte_sums_a),
-					     "+x" (v_byte_sums_b),
-					     "+x" (v_byte_sums_c),
-					     "+x" (v_byte_sums_d));
-			#endif
-				p += 2*VL;
-				n -= 2*VL;
-			} while (n >= 2*VL);
-
-			/*
-			 * Calculate v_s2 as (2*VL)*v_s1_sums +
-			 * [2*VL, 2*VL - 1, 2*VL - 2, ..., 1] * v_byte_sums.
-			 * Then update s1 and s2 from v_s1 and v_s2.
-			 */
-			v_s2 = VADD32_5X(VSLL32(v_s1_sums, LOG2_VL + 1),
-					 VMADD16(v_byte_sums_a, mults_a),
-					 VMADD16(v_byte_sums_b, mults_b),
-					 VMADD16(v_byte_sums_c, mults_c),
-					 VMADD16(v_byte_sums_d, mults_d));
-			reduce_to_32bits(v_s1, v_s2, &s1, &s2);
-		}
-		/*
-		 * Process the last 0 <= n < 2*VL bytes of the chunk using
-		 * scalar instructions and reduce s1 and s2 mod DIVISOR.
-		 */
-		ADLER32_CHUNK(s1, s2, p, n);
-	}
-#endif /* !USE_VNNI */
-	return (s2 << 16) | s1;
-}
-
-#undef vec_t
-#undef mask_t
-#undef LOG2_VL
-#undef VADD8
-#undef VADD16
-#undef VADD32
-#undef VDPBUSD
-#undef VLOAD
-#undef VLOADU
-#undef VMADD16
-#undef VMASKZ_LOADU
-#undef VMULLO32
-#undef VSAD8
-#undef VSET1_8
-#undef VSET1_32
-#undef VSETZERO
-#undef VSLL32
-#undef VUNPACKLO8
-#undef VUNPACKHI8
-
-#undef SUFFIX
-#undef ATTRIBUTES
-#undef VL
-#undef USE_VNNI
-#undef USE_AVX512
diff --git a/vendor/core/vendor/libdeflate/lib/x86/cpu_features.c b/vendor/core/vendor/libdeflate/lib/x86/cpu_features.c
deleted file mode 100644
index a4e09ada..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/cpu_features.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * x86/cpu_features.c - feature detection for x86 CPUs
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "../cpu_features_common.h" /* must be included first */
-#include "cpu_features.h"
-
-#ifdef X86_CPU_FEATURES_KNOWN
-/* Runtime x86 CPU feature detection is supported. */
-
-/* Execute the CPUID instruction. */
-static inline void
-cpuid(u32 leaf, u32 subleaf, u32 *a, u32 *b, u32 *c, u32 *d)
-{
-#ifdef _MSC_VER
-	int result[4];
-
-	__cpuidex(result, leaf, subleaf);
-	*a = result[0];
-	*b = result[1];
-	*c = result[2];
-	*d = result[3];
-#else
-	__asm__ volatile("cpuid" : "=a" (*a), "=b" (*b), "=c" (*c), "=d" (*d)
-			 : "a" (leaf), "c" (subleaf));
-#endif
-}
-
-/* Read an extended control register. */
-static inline u64
-read_xcr(u32 index)
-{
-#ifdef _MSC_VER
-	return _xgetbv(index);
-#else
-	u32 d, a;
-
-	/*
-	 * Execute the "xgetbv" instruction.  Old versions of binutils do not
-	 * recognize this instruction, so list the raw bytes instead.
-	 *
-	 * This must be 'volatile' to prevent this code from being moved out
-	 * from under the check for OSXSAVE.
-	 */
-	__asm__ volatile(".byte 0x0f, 0x01, 0xd0" :
-			 "=d" (d), "=a" (a) : "c" (index));
-
-	return ((u64)d << 32) | a;
-#endif
-}
-
-static const struct cpu_feature x86_cpu_feature_table[] = {
-	{X86_CPU_FEATURE_SSE2,		"sse2"},
-	{X86_CPU_FEATURE_PCLMULQDQ,	"pclmulqdq"},
-	{X86_CPU_FEATURE_AVX,		"avx"},
-	{X86_CPU_FEATURE_AVX2,		"avx2"},
-	{X86_CPU_FEATURE_BMI2,		"bmi2"},
-	{X86_CPU_FEATURE_ZMM,		"zmm"},
-	{X86_CPU_FEATURE_AVX512BW,	"avx512bw"},
-	{X86_CPU_FEATURE_AVX512VL,	"avx512vl"},
-	{X86_CPU_FEATURE_VPCLMULQDQ,	"vpclmulqdq"},
-	{X86_CPU_FEATURE_AVX512VNNI,	"avx512_vnni"},
-	{X86_CPU_FEATURE_AVXVNNI,	"avx_vnni"},
-};
-
-volatile u32 libdeflate_x86_cpu_features = 0;
-
-static inline bool
-os_supports_avx512(u64 xcr0)
-{
-#ifdef __APPLE__
-	/*
-	 * The Darwin kernel had a bug where it could corrupt the opmask
-	 * registers.  See
-	 * https://community.intel.com/t5/Software-Tuning-Performance/MacOS-Darwin-kernel-bug-clobbers-AVX-512-opmask-register-state/m-p/1327259
-	 * Darwin also does not initially set the XCR0 bits for AVX512, but they
-	 * are set if the thread tries to use AVX512 anyway.  Thus, to safely
-	 * and consistently use AVX512 on macOS we'd need to check the kernel
-	 * version as well as detect AVX512 support using a macOS-specific
-	 * method.  We don't bother with this, especially given Apple's
-	 * transition to arm64.
-	 */
-	return false;
-#else
-	return (xcr0 & 0xe6) == 0xe6;
-#endif
-}
-
-/*
- * Don't use 512-bit vectors (ZMM registers) on Intel CPUs before Rocket Lake
- * and Sapphire Rapids, due to the overly-eager downclocking which can reduce
- * the performance of workloads that use ZMM registers only occasionally.
- */
-static inline bool
-allow_512bit_vectors(const u32 manufacturer[3], u32 family, u32 model)
-{
-#ifdef TEST_SUPPORT__DO_NOT_USE
-	return true;
-#endif
-	if (memcmp(manufacturer, "GenuineIntel", 12) != 0)
-		return true;
-	if (family != 6)
-		return true;
-	switch (model) {
-	case 85: /* Skylake (Server), Cascade Lake, Cooper Lake */
-	case 106: /* Ice Lake (Server) */
-	case 108: /* Ice Lake (Server) */
-	case 126: /* Ice Lake (Client) */
-	case 140: /* Tiger Lake */
-	case 141: /* Tiger Lake */
-		return false;
-	}
-	return true;
-}
-
-/* Initialize libdeflate_x86_cpu_features. */
-void libdeflate_init_x86_cpu_features(void)
-{
-	u32 max_leaf;
-	u32 manufacturer[3];
-	u32 family, model;
-	u32 a, b, c, d;
-	u64 xcr0 = 0;
-	u32 features = 0;
-
-	/* EAX=0: Highest Function Parameter and Manufacturer ID */
-	cpuid(0, 0, &max_leaf, &manufacturer[0], &manufacturer[2],
-	      &manufacturer[1]);
-	if (max_leaf < 1)
-		goto out;
-
-	/* EAX=1: Processor Info and Feature Bits */
-	cpuid(1, 0, &a, &b, &c, &d);
-	family = (a >> 8) & 0xf;
-	model = (a >> 4) & 0xf;
-	if (family == 6 || family == 0xf)
-		model += (a >> 12) & 0xf0;
-	if (family == 0xf)
-		family += (a >> 20) & 0xff;
-	if (d & (1 << 26))
-		features |= X86_CPU_FEATURE_SSE2;
-	/*
-	 * No known CPUs have pclmulqdq without sse4.1, so in practice code
-	 * targeting pclmulqdq can use sse4.1 instructions.  But to be safe,
-	 * explicitly check for both the pclmulqdq and sse4.1 bits.
-	 */
-	if ((c & (1 << 1)) && (c & (1 << 19)))
-		features |= X86_CPU_FEATURE_PCLMULQDQ;
-	if (c & (1 << 27))
-		xcr0 = read_xcr(0);
-	if ((c & (1 << 28)) && ((xcr0 & 0x6) == 0x6))
-		features |= X86_CPU_FEATURE_AVX;
-
-	if (max_leaf < 7)
-		goto out;
-
-	/* EAX=7, ECX=0: Extended Features */
-	cpuid(7, 0, &a, &b, &c, &d);
-	if (b & (1 << 8))
-		features |= X86_CPU_FEATURE_BMI2;
-	if ((xcr0 & 0x6) == 0x6) {
-		if (b & (1 << 5))
-			features |= X86_CPU_FEATURE_AVX2;
-		if (c & (1 << 10))
-			features |= X86_CPU_FEATURE_VPCLMULQDQ;
-	}
-	if (os_supports_avx512(xcr0)) {
-		if (allow_512bit_vectors(manufacturer, family, model))
-			features |= X86_CPU_FEATURE_ZMM;
-		if (b & (1 << 30))
-			features |= X86_CPU_FEATURE_AVX512BW;
-		if (b & (1U << 31))
-			features |= X86_CPU_FEATURE_AVX512VL;
-		if (c & (1 << 11))
-			features |= X86_CPU_FEATURE_AVX512VNNI;
-	}
-
-	/* EAX=7, ECX=1: Extended Features */
-	cpuid(7, 1, &a, &b, &c, &d);
-	if ((a & (1 << 4)) && ((xcr0 & 0x6) == 0x6))
-		features |= X86_CPU_FEATURE_AVXVNNI;
-
-out:
-	disable_cpu_features_for_testing(&features, x86_cpu_feature_table,
-					 ARRAY_LEN(x86_cpu_feature_table));
-
-	libdeflate_x86_cpu_features = features | X86_CPU_FEATURES_KNOWN;
-}
-
-#endif /* X86_CPU_FEATURES_KNOWN */
diff --git a/vendor/core/vendor/libdeflate/lib/x86/cpu_features.h b/vendor/core/vendor/libdeflate/lib/x86/cpu_features.h
deleted file mode 100644
index cb225b98..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/cpu_features.h
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * x86/cpu_features.h - feature detection for x86 CPUs
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_X86_CPU_FEATURES_H
-#define LIB_X86_CPU_FEATURES_H
-
-#include "../lib_common.h"
-
-#if defined(ARCH_X86_32) || defined(ARCH_X86_64)
-
-#define X86_CPU_FEATURE_SSE2		(1 << 0)
-#define X86_CPU_FEATURE_PCLMULQDQ	(1 << 1)
-#define X86_CPU_FEATURE_AVX		(1 << 2)
-#define X86_CPU_FEATURE_AVX2		(1 << 3)
-#define X86_CPU_FEATURE_BMI2		(1 << 4)
-/*
- * ZMM indicates whether 512-bit vectors (zmm registers) should be used.  On
- * some CPUs, to avoid downclocking issues we don't set ZMM even if the CPU and
- * operating system support AVX-512.  On these CPUs, we may still use AVX-512
- * instructions, but only with xmm and ymm registers.
- */
-#define X86_CPU_FEATURE_ZMM		(1 << 5)
-#define X86_CPU_FEATURE_AVX512BW	(1 << 6)
-#define X86_CPU_FEATURE_AVX512VL	(1 << 7)
-#define X86_CPU_FEATURE_VPCLMULQDQ	(1 << 8)
-#define X86_CPU_FEATURE_AVX512VNNI	(1 << 9)
-#define X86_CPU_FEATURE_AVXVNNI		(1 << 10)
-
-#if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)
-/* Runtime x86 CPU feature detection is supported. */
-#  define X86_CPU_FEATURES_KNOWN	(1U << 31)
-extern volatile u32 libdeflate_x86_cpu_features;
-
-void libdeflate_init_x86_cpu_features(void);
-
-static inline u32 get_x86_cpu_features(void)
-{
-	if (libdeflate_x86_cpu_features == 0)
-		libdeflate_init_x86_cpu_features();
-	return libdeflate_x86_cpu_features;
-}
-/*
- * x86 intrinsics are also supported.  Include the headers needed to use them.
- * Normally just immintrin.h suffices.  With clang in MSVC compatibility mode,
- * immintrin.h incorrectly skips including sub-headers, so include those too.
- */
-#  include <immintrin.h>
-#  if defined(_MSC_VER) && defined(__clang__)
-#    include <tmmintrin.h>
-#    include <smmintrin.h>
-#    include <wmmintrin.h>
-#    include <avxintrin.h>
-#    include <avx2intrin.h>
-#    include <avx512fintrin.h>
-#    include <avx512bwintrin.h>
-#    include <avx512vlintrin.h>
-#    if __has_include(<avx512vlbwintrin.h>)
-#      include <avx512vlbwintrin.h>
-#    endif
-#    if __has_include(<vpclmulqdqintrin.h>)
-#      include <vpclmulqdqintrin.h>
-#    endif
-#    if __has_include(<avx512vnniintrin.h>)
-#      include <avx512vnniintrin.h>
-#    endif
-#    if __has_include(<avx512vlvnniintrin.h>)
-#      include <avx512vlvnniintrin.h>
-#    endif
-#    if __has_include(<avxvnniintrin.h>)
-#      include <avxvnniintrin.h>
-#    endif
-#  endif
-#else
-static inline u32 get_x86_cpu_features(void) { return 0; }
-#endif
-
-#if defined(__SSE2__) || \
-	(defined(_MSC_VER) && \
-	 (defined(ARCH_X86_64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2)))
-#  define HAVE_SSE2(features)		1
-#  define HAVE_SSE2_NATIVE		1
-#else
-#  define HAVE_SSE2(features)		((features) & X86_CPU_FEATURE_SSE2)
-#  define HAVE_SSE2_NATIVE		0
-#endif
-
-#if (defined(__PCLMUL__) && defined(__SSE4_1__)) || \
-	(defined(_MSC_VER) && defined(__AVX2__))
-#  define HAVE_PCLMULQDQ(features)	1
-#else
-#  define HAVE_PCLMULQDQ(features)	((features) & X86_CPU_FEATURE_PCLMULQDQ)
-#endif
-
-#ifdef __AVX__
-#  define HAVE_AVX(features)		1
-#else
-#  define HAVE_AVX(features)		((features) & X86_CPU_FEATURE_AVX)
-#endif
-
-#ifdef __AVX2__
-#  define HAVE_AVX2(features)		1
-#else
-#  define HAVE_AVX2(features)		((features) & X86_CPU_FEATURE_AVX2)
-#endif
-
-#if defined(__BMI2__) || (defined(_MSC_VER) && defined(__AVX2__))
-#  define HAVE_BMI2(features)		1
-#  define HAVE_BMI2_NATIVE		1
-#else
-#  define HAVE_BMI2(features)		((features) & X86_CPU_FEATURE_BMI2)
-#  define HAVE_BMI2_NATIVE		0
-#endif
-
-#ifdef __AVX512BW__
-#  define HAVE_AVX512BW(features)	1
-#else
-#  define HAVE_AVX512BW(features)	((features) & X86_CPU_FEATURE_AVX512BW)
-#endif
-
-#ifdef __AVX512VL__
-#  define HAVE_AVX512VL(features)	1
-#else
-#  define HAVE_AVX512VL(features)	((features) & X86_CPU_FEATURE_AVX512VL)
-#endif
-
-#ifdef __VPCLMULQDQ__
-#  define HAVE_VPCLMULQDQ(features)	1
-#else
-#  define HAVE_VPCLMULQDQ(features)	((features) & X86_CPU_FEATURE_VPCLMULQDQ)
-#endif
-
-#ifdef __AVX512VNNI__
-#  define HAVE_AVX512VNNI(features)	1
-#else
-#  define HAVE_AVX512VNNI(features)	((features) & X86_CPU_FEATURE_AVX512VNNI)
-#endif
-
-#ifdef __AVXVNNI__
-#  define HAVE_AVXVNNI(features)	1
-#else
-#  define HAVE_AVXVNNI(features)	((features) & X86_CPU_FEATURE_AVXVNNI)
-#endif
-
-#endif /* ARCH_X86_32 || ARCH_X86_64 */
-
-#endif /* LIB_X86_CPU_FEATURES_H */
diff --git a/vendor/core/vendor/libdeflate/lib/x86/crc32_impl.h b/vendor/core/vendor/libdeflate/lib/x86/crc32_impl.h
deleted file mode 100644
index 4fbdef7e..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/crc32_impl.h
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * x86/crc32_impl.h - x86 implementations of the gzip CRC-32 algorithm
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_X86_CRC32_IMPL_H
-#define LIB_X86_CRC32_IMPL_H
-
-#include "cpu_features.h"
-
-/*
- * pshufb(x, shift_tab[len..len+15]) left shifts x by 16-len bytes.
- * pshufb(x, shift_tab[len+16..len+31]) right shifts x by len bytes.
- */
-static const u8 MAYBE_UNUSED shift_tab[48] = {
-	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-};
-
-#if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)
-/*
- * PCLMULQDQ implementation.  This targets PCLMULQDQ+SSE4.1, since in practice
- * all CPUs that support PCLMULQDQ also support SSE4.1.
- */
-#  define crc32_x86_pclmulqdq	crc32_x86_pclmulqdq
-#  define SUFFIX			 _pclmulqdq
-#  define ATTRIBUTES		_target_attribute("pclmul,sse4.1")
-#  define VL			16
-#  define USE_AVX512		0
-#  include "crc32_pclmul_template.h"
-
-/*
- * PCLMULQDQ/AVX implementation.  Same as above, but this is compiled with AVX
- * enabled so that the compiler can generate VEX-coded instructions which can be
- * slightly more efficient.  It still uses 128-bit vectors.
- */
-#  define crc32_x86_pclmulqdq_avx	crc32_x86_pclmulqdq_avx
-#  define SUFFIX				 _pclmulqdq_avx
-#  define ATTRIBUTES		_target_attribute("pclmul,avx")
-#  define VL			16
-#  define USE_AVX512		0
-#  include "crc32_pclmul_template.h"
-#endif
-
-/*
- * VPCLMULQDQ/AVX2 implementation.  This is used on CPUs that have AVX2 and
- * VPCLMULQDQ but don't have AVX-512, for example Intel Alder Lake.
- *
- * Currently this can't be enabled with MSVC because MSVC has a bug where it
- * incorrectly assumes that VPCLMULQDQ implies AVX-512:
- * https://developercommunity.visualstudio.com/t/Compiler-incorrectly-assumes-VAES-and-VP/10578785
- *
- * gcc 8.1 and 8.2 had a similar bug where they assumed that
- * _mm256_clmulepi64_epi128() always needed AVX512.  It's fixed in gcc 8.3.
- *
- * _mm256_zextsi128_si256() requires gcc 10.
- */
-#if (GCC_PREREQ(10, 1) || CLANG_PREREQ(6, 0, 10000000)) && \
-	!defined(LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_VPCLMULQDQ)
-#  define crc32_x86_vpclmulqdq_avx2	crc32_x86_vpclmulqdq_avx2
-#  define SUFFIX				 _vpclmulqdq_avx2
-#  define ATTRIBUTES		_target_attribute("vpclmulqdq,pclmul,avx2")
-#  define VL			32
-#  define USE_AVX512		0
-#  include "crc32_pclmul_template.h"
-#endif
-
-#if (GCC_PREREQ(10, 1) || CLANG_PREREQ(6, 0, 10000000) || MSVC_PREREQ(1920)) && \
-	!(CLANG_PREREQ(18, 0, 18000000) && !CLANG_PREREQ(19, 0, 19000000)) && \
-	!defined(LIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_VPCLMULQDQ)
-/*
- * VPCLMULQDQ/AVX512 implementation using 256-bit vectors.  This is very similar
- * to the VPCLMULQDQ/AVX2 implementation but takes advantage of the vpternlog
- * instruction and more registers.  This is used on certain older Intel CPUs,
- * specifically Ice Lake and Tiger Lake, which support VPCLMULQDQ and AVX512 but
- * downclock a bit too eagerly when ZMM registers are used.
- *
- * _mm256_zextsi128_si256() requires gcc 10.
- */
-#  define crc32_x86_vpclmulqdq_avx512_vl256  crc32_x86_vpclmulqdq_avx512_vl256
-#  define SUFFIX				      _vpclmulqdq_avx512_vl256
-#  define ATTRIBUTES		_target_attribute("vpclmulqdq,pclmul,avx512bw,avx512vl")
-#  define VL			32
-#  define USE_AVX512		1
-#  include "crc32_pclmul_template.h"
-
-/*
- * VPCLMULQDQ/AVX512 implementation using 512-bit vectors.  This is used on CPUs
- * that have a good AVX-512 implementation including VPCLMULQDQ.
- *
- * _mm512_zextsi128_si512() requires gcc 10.
- */
-#  define crc32_x86_vpclmulqdq_avx512_vl512  crc32_x86_vpclmulqdq_avx512_vl512
-#  define SUFFIX				      _vpclmulqdq_avx512_vl512
-#  define ATTRIBUTES		_target_attribute("vpclmulqdq,pclmul,avx512bw,avx512vl")
-#  define VL			64
-#  define USE_AVX512		1
-#  include "crc32_pclmul_template.h"
-#endif
-
-static inline crc32_func_t
-arch_select_crc32_func(void)
-{
-	const u32 features MAYBE_UNUSED = get_x86_cpu_features();
-
-#ifdef crc32_x86_vpclmulqdq_avx512_vl512
-	if ((features & X86_CPU_FEATURE_ZMM) &&
-	    HAVE_VPCLMULQDQ(features) && HAVE_PCLMULQDQ(features) &&
-	    HAVE_AVX512BW(features) && HAVE_AVX512VL(features))
-		return crc32_x86_vpclmulqdq_avx512_vl512;
-#endif
-#ifdef crc32_x86_vpclmulqdq_avx512_vl256
-	if (HAVE_VPCLMULQDQ(features) && HAVE_PCLMULQDQ(features) &&
-	    HAVE_AVX512BW(features) && HAVE_AVX512VL(features))
-		return crc32_x86_vpclmulqdq_avx512_vl256;
-#endif
-#ifdef crc32_x86_vpclmulqdq_avx2
-	if (HAVE_VPCLMULQDQ(features) && HAVE_PCLMULQDQ(features) &&
-	    HAVE_AVX2(features))
-		return crc32_x86_vpclmulqdq_avx2;
-#endif
-#ifdef crc32_x86_pclmulqdq_avx
-	if (HAVE_PCLMULQDQ(features) && HAVE_AVX(features))
-		return crc32_x86_pclmulqdq_avx;
-#endif
-#ifdef crc32_x86_pclmulqdq
-	if (HAVE_PCLMULQDQ(features))
-		return crc32_x86_pclmulqdq;
-#endif
-	return NULL;
-}
-#define arch_select_crc32_func	arch_select_crc32_func
-
-#endif /* LIB_X86_CRC32_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/x86/crc32_pclmul_template.h b/vendor/core/vendor/libdeflate/lib/x86/crc32_pclmul_template.h
deleted file mode 100644
index 8bb8bfd3..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/crc32_pclmul_template.h
+++ /dev/null
@@ -1,424 +0,0 @@
-/*
- * x86/crc32_pclmul_template.h - gzip CRC-32 with PCLMULQDQ instructions
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-/*
- * This file is a "template" for instantiating PCLMULQDQ-based crc32_x86
- * functions.  The "parameters" are:
- *
- * SUFFIX:
- *	Name suffix to append to all instantiated functions.
- * ATTRIBUTES:
- *	Target function attributes to use.  Must satisfy the dependencies of the
- *	other parameters as follows:
- *	   VL=16 && USE_AVX512=0: at least pclmul,sse4.1
- *	   VL=32 && USE_AVX512=0: at least vpclmulqdq,pclmul,avx2
- *	   VL=32 && USE_AVX512=1: at least vpclmulqdq,pclmul,avx512bw,avx512vl
- *	   VL=64 && USE_AVX512=1: at least vpclmulqdq,pclmul,avx512bw,avx512vl
- *	   (Other combinations are not useful and have not been tested.)
- * VL:
- *	Vector length in bytes.  Must be 16, 32, or 64.
- * USE_AVX512:
- *	If 1, take advantage of AVX-512 features such as masking and the
- *	vpternlog instruction.  This doesn't enable the use of 512-bit vectors;
- *	the vector length is controlled by VL.  If 0, assume that the CPU might
- *	not support AVX-512.
- *
- * The overall algorithm used is CRC folding with carryless multiplication
- * instructions.  Note that the x86 crc32 instruction cannot be used, as it is
- * for a different polynomial, not the gzip one.  For an explanation of CRC
- * folding with carryless multiplication instructions, see
- * scripts/gen-crc32-consts.py and the following blog posts and papers:
- *
- *	"An alternative exposition of crc32_4k_pclmulqdq"
- *	https://www.corsix.org/content/alternative-exposition-crc32_4k_pclmulqdq
- *
- *	"Fast CRC Computation for Generic Polynomials Using PCLMULQDQ Instruction"
- *	https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
- *
- * The original pclmulqdq instruction does one 64x64 to 128-bit carryless
- * multiplication.  The VPCLMULQDQ feature added instructions that do two
- * parallel 64x64 to 128-bit carryless multiplications in combination with AVX
- * or AVX512VL, or four in combination with AVX512F.
- */
-
-#if VL == 16
-#  define vec_t			__m128i
-#  define fold_vec		fold_vec128
-#  define VLOADU(p)		_mm_loadu_si128((const void *)(p))
-#  define VXOR(a, b)		_mm_xor_si128((a), (b))
-#  define M128I_TO_VEC(a)	a
-#  define MULTS_8V		_mm_set_epi64x(CRC32_X991_MODG, CRC32_X1055_MODG)
-#  define MULTS_4V		_mm_set_epi64x(CRC32_X479_MODG, CRC32_X543_MODG)
-#  define MULTS_2V		_mm_set_epi64x(CRC32_X223_MODG, CRC32_X287_MODG)
-#  define MULTS_1V		_mm_set_epi64x(CRC32_X95_MODG, CRC32_X159_MODG)
-#elif VL == 32
-#  define vec_t			__m256i
-#  define fold_vec		fold_vec256
-#  define VLOADU(p)		_mm256_loadu_si256((const void *)(p))
-#  define VXOR(a, b)		_mm256_xor_si256((a), (b))
-#  define M128I_TO_VEC(a)	_mm256_zextsi128_si256(a)
-#  define MULTS(a, b)		_mm256_set_epi64x(a, b, a, b)
-#  define MULTS_8V		MULTS(CRC32_X2015_MODG, CRC32_X2079_MODG)
-#  define MULTS_4V		MULTS(CRC32_X991_MODG, CRC32_X1055_MODG)
-#  define MULTS_2V		MULTS(CRC32_X479_MODG, CRC32_X543_MODG)
-#  define MULTS_1V		MULTS(CRC32_X223_MODG, CRC32_X287_MODG)
-#elif VL == 64
-#  define vec_t			__m512i
-#  define fold_vec		fold_vec512
-#  define VLOADU(p)		_mm512_loadu_si512((const void *)(p))
-#  define VXOR(a, b)		_mm512_xor_si512((a), (b))
-#  define M128I_TO_VEC(a)	_mm512_zextsi128_si512(a)
-#  define MULTS(a, b)		_mm512_set_epi64(a, b, a, b, a, b, a, b)
-#  define MULTS_8V		MULTS(CRC32_X4063_MODG, CRC32_X4127_MODG)
-#  define MULTS_4V		MULTS(CRC32_X2015_MODG, CRC32_X2079_MODG)
-#  define MULTS_2V		MULTS(CRC32_X991_MODG, CRC32_X1055_MODG)
-#  define MULTS_1V		MULTS(CRC32_X479_MODG, CRC32_X543_MODG)
-#else
-#  error "unsupported vector length"
-#endif
-
-#undef fold_vec128
-static forceinline ATTRIBUTES __m128i
-ADD_SUFFIX(fold_vec128)(__m128i src, __m128i dst, __m128i /* __v2du */ mults)
-{
-	dst = _mm_xor_si128(dst, _mm_clmulepi64_si128(src, mults, 0x00));
-	dst = _mm_xor_si128(dst, _mm_clmulepi64_si128(src, mults, 0x11));
-	return dst;
-}
-#define fold_vec128	ADD_SUFFIX(fold_vec128)
-
-#if VL >= 32
-#undef fold_vec256
-static forceinline ATTRIBUTES __m256i
-ADD_SUFFIX(fold_vec256)(__m256i src, __m256i dst, __m256i /* __v4du */ mults)
-{
-#if USE_AVX512
-	/* vpternlog with immediate 0x96 is a three-argument XOR. */
-	return _mm256_ternarylogic_epi32(
-			_mm256_clmulepi64_epi128(src, mults, 0x00),
-			_mm256_clmulepi64_epi128(src, mults, 0x11),
-			dst,
-			0x96);
-#else
-	return _mm256_xor_si256(
-			_mm256_xor_si256(dst,
-					 _mm256_clmulepi64_epi128(src, mults, 0x00)),
-			_mm256_clmulepi64_epi128(src, mults, 0x11));
-#endif
-}
-#define fold_vec256	ADD_SUFFIX(fold_vec256)
-#endif /* VL >= 32 */
-
-#if VL >= 64
-#undef fold_vec512
-static forceinline ATTRIBUTES __m512i
-ADD_SUFFIX(fold_vec512)(__m512i src, __m512i dst, __m512i /* __v8du */ mults)
-{
-	/* vpternlog with immediate 0x96 is a three-argument XOR. */
-	return _mm512_ternarylogic_epi32(
-			_mm512_clmulepi64_epi128(src, mults, 0x00),
-			_mm512_clmulepi64_epi128(src, mults, 0x11),
-			dst,
-			0x96);
-}
-#define fold_vec512	ADD_SUFFIX(fold_vec512)
-#endif /* VL >= 64 */
-
-/*
- * Given 'x' containing a 16-byte polynomial, and a pointer 'p' that points to
- * the next '1 <= len <= 15' data bytes, rearrange the concatenation of 'x' and
- * the data into vectors x0 and x1 that contain 'len' bytes and 16 bytes,
- * respectively.  Then fold x0 into x1 and return the result.
- * Assumes that 'p + len - 16' is in-bounds.
- */
-#undef fold_lessthan16bytes
-static forceinline ATTRIBUTES __m128i
-ADD_SUFFIX(fold_lessthan16bytes)(__m128i x, const u8 *p, size_t len,
-				 __m128i /* __v2du */ mults_128b)
-{
-	__m128i lshift = _mm_loadu_si128((const void *)&shift_tab[len]);
-	__m128i rshift = _mm_loadu_si128((const void *)&shift_tab[len + 16]);
-	__m128i x0, x1;
-
-	/* x0 = x left-shifted by '16 - len' bytes */
-	x0 = _mm_shuffle_epi8(x, lshift);
-
-	/*
-	 * x1 = the last '16 - len' bytes from x (i.e. x right-shifted by 'len'
-	 * bytes) followed by the remaining data.
-	 */
-	x1 = _mm_blendv_epi8(_mm_shuffle_epi8(x, rshift),
-			     _mm_loadu_si128((const void *)(p + len - 16)),
-			     /* msb 0/1 of each byte selects byte from arg1/2 */
-			     rshift);
-
-	return fold_vec128(x0, x1, mults_128b);
-}
-#define fold_lessthan16bytes	ADD_SUFFIX(fold_lessthan16bytes)
-
-static ATTRIBUTES u32
-ADD_SUFFIX(crc32_x86)(u32 crc, const u8 *p, size_t len)
-{
-	/*
-	 * mults_{N}v are the vectors of multipliers for folding across N vec_t
-	 * vectors, i.e. N*VL*8 bits.  mults_128b are the two multipliers for
-	 * folding across 128 bits.  mults_128b differs from mults_1v when
-	 * VL != 16.  All multipliers are 64-bit, to match what pclmulqdq needs,
-	 * but since this is for CRC-32 only their low 32 bits are nonzero.
-	 * For more details, see scripts/gen-crc32-consts.py.
-	 */
-	const vec_t mults_8v = MULTS_8V;
-	const vec_t mults_4v = MULTS_4V;
-	const vec_t mults_2v = MULTS_2V;
-	const vec_t mults_1v = MULTS_1V;
-	const __m128i mults_128b = _mm_set_epi64x(CRC32_X95_MODG, CRC32_X159_MODG);
-	const __m128i barrett_reduction_constants =
-		_mm_set_epi64x(CRC32_BARRETT_CONSTANT_2, CRC32_BARRETT_CONSTANT_1);
-	vec_t v0, v1, v2, v3, v4, v5, v6, v7;
-	__m128i x0 = _mm_cvtsi32_si128(crc);
-	__m128i x1;
-
-	if (len < 8*VL) {
-		if (len < VL) {
-			STATIC_ASSERT(VL == 16 || VL == 32 || VL == 64);
-			if (len < 16) {
-			#if USE_AVX512
-				if (len < 4)
-					return crc32_slice1(crc, p, len);
-				/*
-				 * Handle 4 <= len <= 15 bytes by doing a masked
-				 * load, XOR'ing the current CRC with the first
-				 * 4 bytes, left-shifting by '16 - len' bytes to
-				 * align the result to the end of x0 (so that it
-				 * becomes the low-order coefficients of a
-				 * 128-bit polynomial), and then doing the usual
-				 * reduction from 128 bits to 32 bits.
-				 */
-				x0 = _mm_xor_si128(
-					x0, _mm_maskz_loadu_epi8((1 << len) - 1, p));
-				x0 = _mm_shuffle_epi8(
-					x0, _mm_loadu_si128((const void *)&shift_tab[len]));
-				goto reduce_x0;
-			#else
-				return crc32_slice1(crc, p, len);
-			#endif
-			}
-			/*
-			 * Handle 16 <= len < VL bytes where VL is 32 or 64.
-			 * Use 128-bit instructions so that these lengths aren't
-			 * slower with VL > 16 than with VL=16.
-			 */
-			x0 = _mm_xor_si128(_mm_loadu_si128((const void *)p), x0);
-			if (len >= 32) {
-				x0 = fold_vec128(x0, _mm_loadu_si128((const void *)(p + 16)),
-						 mults_128b);
-				if (len >= 48)
-					x0 = fold_vec128(x0, _mm_loadu_si128((const void *)(p + 32)),
-							 mults_128b);
-			}
-			p += len & ~15;
-			goto less_than_16_remaining;
-		}
-		v0 = VXOR(VLOADU(p), M128I_TO_VEC(x0));
-		if (len < 2*VL) {
-			p += VL;
-			goto less_than_vl_remaining;
-		}
-		v1 = VLOADU(p + 1*VL);
-		if (len < 4*VL) {
-			p += 2*VL;
-			goto less_than_2vl_remaining;
-		}
-		v2 = VLOADU(p + 2*VL);
-		v3 = VLOADU(p + 3*VL);
-		p += 4*VL;
-	} else {
-		/*
-		 * If the length is large and the pointer is misaligned, align
-		 * it.  For smaller lengths, just take the misaligned load
-		 * penalty.  Note that on recent x86 CPUs, vmovdqu with an
-		 * aligned address is just as fast as vmovdqa, so there's no
-		 * need to use vmovdqa in the main loop.
-		 */
-		if (len > 65536 && ((uintptr_t)p & (VL-1))) {
-			size_t align = -(uintptr_t)p & (VL-1);
-
-			len -= align;
-			x0 = _mm_xor_si128(_mm_loadu_si128((const void *)p), x0);
-			p += 16;
-			if (align & 15) {
-				x0 = fold_lessthan16bytes(x0, p, align & 15,
-							  mults_128b);
-				p += align & 15;
-				align &= ~15;
-			}
-			while (align) {
-				x0 = fold_vec128(x0, *(const __m128i *)p,
-						 mults_128b);
-				p += 16;
-				align -= 16;
-			}
-			v0 = M128I_TO_VEC(x0);
-		#  if VL == 32
-			v0 = _mm256_inserti128_si256(v0, *(const __m128i *)p, 1);
-		#  elif VL == 64
-			v0 = _mm512_inserti32x4(v0, *(const __m128i *)p, 1);
-			v0 = _mm512_inserti64x4(v0, *(const __m256i *)(p + 16), 1);
-		#  endif
-			p -= 16;
-		} else {
-			v0 = VXOR(VLOADU(p), M128I_TO_VEC(x0));
-		}
-		v1 = VLOADU(p + 1*VL);
-		v2 = VLOADU(p + 2*VL);
-		v3 = VLOADU(p + 3*VL);
-		v4 = VLOADU(p + 4*VL);
-		v5 = VLOADU(p + 5*VL);
-		v6 = VLOADU(p + 6*VL);
-		v7 = VLOADU(p + 7*VL);
-		p += 8*VL;
-
-		/*
-		 * This is the main loop, processing 8*VL bytes per iteration.
-		 * 4*VL is usually enough and would result in smaller code, but
-		 * Skylake and Cascade Lake need 8*VL to get full performance.
-		 */
-		while (len >= 16*VL) {
-			v0 = fold_vec(v0, VLOADU(p + 0*VL), mults_8v);
-			v1 = fold_vec(v1, VLOADU(p + 1*VL), mults_8v);
-			v2 = fold_vec(v2, VLOADU(p + 2*VL), mults_8v);
-			v3 = fold_vec(v3, VLOADU(p + 3*VL), mults_8v);
-			v4 = fold_vec(v4, VLOADU(p + 4*VL), mults_8v);
-			v5 = fold_vec(v5, VLOADU(p + 5*VL), mults_8v);
-			v6 = fold_vec(v6, VLOADU(p + 6*VL), mults_8v);
-			v7 = fold_vec(v7, VLOADU(p + 7*VL), mults_8v);
-			p += 8*VL;
-			len -= 8*VL;
-		}
-
-		/* Fewer than 8*VL bytes remain. */
-		v0 = fold_vec(v0, v4, mults_4v);
-		v1 = fold_vec(v1, v5, mults_4v);
-		v2 = fold_vec(v2, v6, mults_4v);
-		v3 = fold_vec(v3, v7, mults_4v);
-		if (len & (4*VL)) {
-			v0 = fold_vec(v0, VLOADU(p + 0*VL), mults_4v);
-			v1 = fold_vec(v1, VLOADU(p + 1*VL), mults_4v);
-			v2 = fold_vec(v2, VLOADU(p + 2*VL), mults_4v);
-			v3 = fold_vec(v3, VLOADU(p + 3*VL), mults_4v);
-			p += 4*VL;
-		}
-	}
-	/* Fewer than 4*VL bytes remain. */
-	v0 = fold_vec(v0, v2, mults_2v);
-	v1 = fold_vec(v1, v3, mults_2v);
-	if (len & (2*VL)) {
-		v0 = fold_vec(v0, VLOADU(p + 0*VL), mults_2v);
-		v1 = fold_vec(v1, VLOADU(p + 1*VL), mults_2v);
-		p += 2*VL;
-	}
-less_than_2vl_remaining:
-	/* Fewer than 2*VL bytes remain. */
-	v0 = fold_vec(v0, v1, mults_1v);
-	if (len & VL) {
-		v0 = fold_vec(v0, VLOADU(p), mults_1v);
-		p += VL;
-	}
-less_than_vl_remaining:
-	/*
-	 * Fewer than VL bytes remain.  Reduce v0 (length VL bytes) to x0
-	 * (length 16 bytes) and fold in any 16-byte data segments that remain.
-	 */
-#if VL == 16
-	x0 = v0;
-#else
-	{
-	#if VL == 32
-		__m256i y0 = v0;
-	#else
-		const __m256i mults_256b =
-			_mm256_set_epi64x(CRC32_X223_MODG, CRC32_X287_MODG,
-					  CRC32_X223_MODG, CRC32_X287_MODG);
-		__m256i y0 = fold_vec256(_mm512_extracti64x4_epi64(v0, 0),
-					 _mm512_extracti64x4_epi64(v0, 1),
-					 mults_256b);
-		if (len & 32) {
-			y0 = fold_vec256(y0, _mm256_loadu_si256((const void *)p),
-					 mults_256b);
-			p += 32;
-		}
-	#endif
-		x0 = fold_vec128(_mm256_extracti128_si256(y0, 0),
-				 _mm256_extracti128_si256(y0, 1), mults_128b);
-	}
-	if (len & 16) {
-		x0 = fold_vec128(x0, _mm_loadu_si128((const void *)p),
-				 mults_128b);
-		p += 16;
-	}
-#endif
-less_than_16_remaining:
-	len &= 15;
-
-	/* Handle any remainder of 1 to 15 bytes. */
-	if (len)
-		x0 = fold_lessthan16bytes(x0, p, len, mults_128b);
-#if USE_AVX512
-reduce_x0:
-#endif
-	/*
-	 * Multiply the remaining 128-bit message polynomial 'x0' by x^32, then
-	 * reduce it modulo the generator polynomial G.  This gives the CRC.
-	 *
-	 * This implementation matches that used in crc-pclmul-template.S from
-	 * https://lore.kernel.org/r/20250210174540.161705-4-ebiggers@kernel.org/
-	 * with the parameters n=32 and LSB_CRC=1 (what the gzip CRC uses).  See
-	 * there for a detailed explanation of the math used here.
-	 */
-	x0 = _mm_xor_si128(_mm_clmulepi64_si128(x0, mults_128b, 0x10),
-			   _mm_bsrli_si128(x0, 8));
-	x1 = _mm_clmulepi64_si128(x0, barrett_reduction_constants, 0x00);
-	x1 = _mm_clmulepi64_si128(x1, barrett_reduction_constants, 0x10);
-	x0 = _mm_xor_si128(x0, x1);
-	return _mm_extract_epi32(x0, 2);
-}
-
-#undef vec_t
-#undef fold_vec
-#undef VLOADU
-#undef VXOR
-#undef M128I_TO_VEC
-#undef MULTS
-#undef MULTS_8V
-#undef MULTS_4V
-#undef MULTS_2V
-#undef MULTS_1V
-
-#undef SUFFIX
-#undef ATTRIBUTES
-#undef VL
-#undef USE_AVX512
diff --git a/vendor/core/vendor/libdeflate/lib/x86/decompress_impl.h b/vendor/core/vendor/libdeflate/lib/x86/decompress_impl.h
deleted file mode 100644
index daedcf2d..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/decompress_impl.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef LIB_X86_DECOMPRESS_IMPL_H
-#define LIB_X86_DECOMPRESS_IMPL_H
-
-#include "cpu_features.h"
-
-/*
- * BMI2 optimized decompression function.
- *
- * With gcc and clang we just compile the whole function with
- * __attribute__((target("bmi2"))), and the compiler uses bmi2 automatically.
- *
- * With MSVC, there is no target function attribute, but it's still possible to
- * use bmi2 intrinsics explicitly.  Currently we mostly don't, but there's a
- * case in which we do (see below), so we at least take advantage of that.
- * However, MSVC from VS2017 (toolset v141) apparently miscompiles the _bzhi_*()
- * intrinsics.  It seems to be fixed in VS2022.  Hence, use MSVC_PREREQ(1930).
- */
-#if defined(__GNUC__) || defined(__clang__) || MSVC_PREREQ(1930)
-#  define deflate_decompress_bmi2	deflate_decompress_bmi2
-#  define FUNCNAME			deflate_decompress_bmi2
-#  define ATTRIBUTES			_target_attribute("bmi2")
-   /*
-    * Even with __attribute__((target("bmi2"))), gcc doesn't reliably use the
-    * bzhi instruction for 'word & BITMASK(count)'.  So use the bzhi intrinsic
-    * explicitly.  EXTRACT_VARBITS() is equivalent to 'word & BITMASK(count)';
-    * EXTRACT_VARBITS8() is equivalent to 'word & BITMASK((u8)count)'.
-    * Nevertheless, their implementation using the bzhi intrinsic is identical,
-    * as the bzhi instruction truncates the count to 8 bits implicitly.
-    */
-#  ifndef __clang__
-#    ifdef ARCH_X86_64
-#      define EXTRACT_VARBITS(word, count)  _bzhi_u64((word), (count))
-#      define EXTRACT_VARBITS8(word, count) _bzhi_u64((word), (count))
-#    else
-#      define EXTRACT_VARBITS(word, count)  _bzhi_u32((word), (count))
-#      define EXTRACT_VARBITS8(word, count) _bzhi_u32((word), (count))
-#    endif
-#  endif
-#  include "../decompress_template.h"
-#endif
-
-#if defined(deflate_decompress_bmi2) && HAVE_BMI2_NATIVE
-#define DEFAULT_IMPL	deflate_decompress_bmi2
-#else
-static inline decompress_func_t
-arch_select_decompress_func(void)
-{
-#ifdef deflate_decompress_bmi2
-	if (HAVE_BMI2(get_x86_cpu_features()))
-		return deflate_decompress_bmi2;
-#endif
-	return NULL;
-}
-#define arch_select_decompress_func	arch_select_decompress_func
-#endif
-
-#endif /* LIB_X86_DECOMPRESS_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/x86/matchfinder_impl.h b/vendor/core/vendor/libdeflate/lib/x86/matchfinder_impl.h
deleted file mode 100644
index 37a4960a..00000000
--- a/vendor/core/vendor/libdeflate/lib/x86/matchfinder_impl.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * x86/matchfinder_impl.h - x86 implementations of matchfinder functions
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#ifndef LIB_X86_MATCHFINDER_IMPL_H
-#define LIB_X86_MATCHFINDER_IMPL_H
-
-#include "cpu_features.h"
-
-#ifdef __AVX2__
-static forceinline void
-matchfinder_init_avx2(mf_pos_t *data, size_t size)
-{
-	__m256i *p = (__m256i *)data;
-	__m256i v = _mm256_set1_epi16(MATCHFINDER_INITVAL);
-
-	STATIC_ASSERT(MATCHFINDER_MEM_ALIGNMENT % sizeof(*p) == 0);
-	STATIC_ASSERT(MATCHFINDER_SIZE_ALIGNMENT % (4 * sizeof(*p)) == 0);
-	STATIC_ASSERT(sizeof(mf_pos_t) == 2);
-
-	do {
-		p[0] = v;
-		p[1] = v;
-		p[2] = v;
-		p[3] = v;
-		p += 4;
-		size -= 4 * sizeof(*p);
-	} while (size != 0);
-}
-#define matchfinder_init matchfinder_init_avx2
-
-static forceinline void
-matchfinder_rebase_avx2(mf_pos_t *data, size_t size)
-{
-	__m256i *p = (__m256i *)data;
-	__m256i v = _mm256_set1_epi16((u16)-MATCHFINDER_WINDOW_SIZE);
-
-	STATIC_ASSERT(MATCHFINDER_MEM_ALIGNMENT % sizeof(*p) == 0);
-	STATIC_ASSERT(MATCHFINDER_SIZE_ALIGNMENT % (4 * sizeof(*p)) == 0);
-	STATIC_ASSERT(sizeof(mf_pos_t) == 2);
-
-	do {
-		/* PADDSW: Add Packed Signed Integers With Signed Saturation  */
-		p[0] = _mm256_adds_epi16(p[0], v);
-		p[1] = _mm256_adds_epi16(p[1], v);
-		p[2] = _mm256_adds_epi16(p[2], v);
-		p[3] = _mm256_adds_epi16(p[3], v);
-		p += 4;
-		size -= 4 * sizeof(*p);
-	} while (size != 0);
-}
-#define matchfinder_rebase matchfinder_rebase_avx2
-
-#elif HAVE_SSE2_NATIVE
-static forceinline void
-matchfinder_init_sse2(mf_pos_t *data, size_t size)
-{
-	__m128i *p = (__m128i *)data;
-	__m128i v = _mm_set1_epi16(MATCHFINDER_INITVAL);
-
-	STATIC_ASSERT(MATCHFINDER_MEM_ALIGNMENT % sizeof(*p) == 0);
-	STATIC_ASSERT(MATCHFINDER_SIZE_ALIGNMENT % (4 * sizeof(*p)) == 0);
-	STATIC_ASSERT(sizeof(mf_pos_t) == 2);
-
-	do {
-		p[0] = v;
-		p[1] = v;
-		p[2] = v;
-		p[3] = v;
-		p += 4;
-		size -= 4 * sizeof(*p);
-	} while (size != 0);
-}
-#define matchfinder_init matchfinder_init_sse2
-
-static forceinline void
-matchfinder_rebase_sse2(mf_pos_t *data, size_t size)
-{
-	__m128i *p = (__m128i *)data;
-	__m128i v = _mm_set1_epi16((u16)-MATCHFINDER_WINDOW_SIZE);
-
-	STATIC_ASSERT(MATCHFINDER_MEM_ALIGNMENT % sizeof(*p) == 0);
-	STATIC_ASSERT(MATCHFINDER_SIZE_ALIGNMENT % (4 * sizeof(*p)) == 0);
-	STATIC_ASSERT(sizeof(mf_pos_t) == 2);
-
-	do {
-		/* PADDSW: Add Packed Signed Integers With Signed Saturation  */
-		p[0] = _mm_adds_epi16(p[0], v);
-		p[1] = _mm_adds_epi16(p[1], v);
-		p[2] = _mm_adds_epi16(p[2], v);
-		p[3] = _mm_adds_epi16(p[3], v);
-		p += 4;
-		size -= 4 * sizeof(*p);
-	} while (size != 0);
-}
-#define matchfinder_rebase matchfinder_rebase_sse2
-#endif /* HAVE_SSE2_NATIVE */
-
-#endif /* LIB_X86_MATCHFINDER_IMPL_H */
diff --git a/vendor/core/vendor/libdeflate/lib/zlib_compress.c b/vendor/core/vendor/libdeflate/lib/zlib_compress.c
deleted file mode 100644
index 12d43602..00000000
--- a/vendor/core/vendor/libdeflate/lib/zlib_compress.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * zlib_compress.c - compress with a zlib wrapper
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "deflate_compress.h"
-#include "zlib_constants.h"
-
-LIBDEFLATEAPI size_t
-libdeflate_zlib_compress(struct libdeflate_compressor *c,
-			 const void *in, size_t in_nbytes,
-			 void *out, size_t out_nbytes_avail)
-{
-	u8 *out_next = out;
-	u16 hdr;
-	unsigned compression_level;
-	unsigned level_hint;
-	size_t deflate_size;
-
-	if (out_nbytes_avail <= ZLIB_MIN_OVERHEAD)
-		return 0;
-
-	/* 2 byte header: CMF and FLG  */
-	hdr = (ZLIB_CM_DEFLATE << 8) | (ZLIB_CINFO_32K_WINDOW << 12);
-	compression_level = libdeflate_get_compression_level(c);
-	if (compression_level < 2)
-		level_hint = ZLIB_FASTEST_COMPRESSION;
-	else if (compression_level < 6)
-		level_hint = ZLIB_FAST_COMPRESSION;
-	else if (compression_level < 8)
-		level_hint = ZLIB_DEFAULT_COMPRESSION;
-	else
-		level_hint = ZLIB_SLOWEST_COMPRESSION;
-	hdr |= level_hint << 6;
-	hdr |= 31 - (hdr % 31);
-
-	put_unaligned_be16(hdr, out_next);
-	out_next += 2;
-
-	/* Compressed data  */
-	deflate_size = libdeflate_deflate_compress(c, in, in_nbytes, out_next,
-					out_nbytes_avail - ZLIB_MIN_OVERHEAD);
-	if (deflate_size == 0)
-		return 0;
-	out_next += deflate_size;
-
-	/* ADLER32  */
-	put_unaligned_be32(libdeflate_adler32(1, in, in_nbytes), out_next);
-	out_next += 4;
-
-	return out_next - (u8 *)out;
-}
-
-LIBDEFLATEAPI size_t
-libdeflate_zlib_compress_bound(struct libdeflate_compressor *c,
-			       size_t in_nbytes)
-{
-	return ZLIB_MIN_OVERHEAD +
-	       libdeflate_deflate_compress_bound(c, in_nbytes);
-}
diff --git a/vendor/core/vendor/libdeflate/lib/zlib_constants.h b/vendor/core/vendor/libdeflate/lib/zlib_constants.h
deleted file mode 100644
index f304310c..00000000
--- a/vendor/core/vendor/libdeflate/lib/zlib_constants.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * zlib_constants.h - constants for the zlib wrapper format
- */
-
-#ifndef LIB_ZLIB_CONSTANTS_H
-#define LIB_ZLIB_CONSTANTS_H
-
-#define ZLIB_MIN_HEADER_SIZE	2
-#define ZLIB_FOOTER_SIZE	4
-#define ZLIB_MIN_OVERHEAD	(ZLIB_MIN_HEADER_SIZE + ZLIB_FOOTER_SIZE)
-
-#define ZLIB_CM_DEFLATE		8
-
-#define ZLIB_CINFO_32K_WINDOW	7
-
-#define ZLIB_FASTEST_COMPRESSION	0
-#define ZLIB_FAST_COMPRESSION		1
-#define ZLIB_DEFAULT_COMPRESSION	2
-#define ZLIB_SLOWEST_COMPRESSION	3
-
-#endif /* LIB_ZLIB_CONSTANTS_H */
diff --git a/vendor/core/vendor/libdeflate/lib/zlib_decompress.c b/vendor/core/vendor/libdeflate/lib/zlib_decompress.c
deleted file mode 100644
index f5e43eae..00000000
--- a/vendor/core/vendor/libdeflate/lib/zlib_decompress.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * zlib_decompress.c - decompress with a zlib wrapper
- *
- * Copyright 2016 Eric Biggers
- *
- * 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.
- */
-
-#include "lib_common.h"
-#include "zlib_constants.h"
-
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_zlib_decompress_ex(struct libdeflate_decompressor *d,
-			      const void *in, size_t in_nbytes,
-			      void *out, size_t out_nbytes_avail,
-			      size_t *actual_in_nbytes_ret,
-			      size_t *actual_out_nbytes_ret)
-{
-	const u8 *in_next = in;
-	const u8 * const in_end = in_next + in_nbytes;
-	u16 hdr;
-	size_t actual_in_nbytes;
-	size_t actual_out_nbytes;
-	enum libdeflate_result result;
-
-	if (in_nbytes < ZLIB_MIN_OVERHEAD)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* 2 byte header: CMF and FLG  */
-	hdr = get_unaligned_be16(in_next);
-	in_next += 2;
-
-	/* FCHECK */
-	if ((hdr % 31) != 0)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* CM */
-	if (((hdr >> 8) & 0xF) != ZLIB_CM_DEFLATE)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* CINFO */
-	if ((hdr >> 12) > ZLIB_CINFO_32K_WINDOW)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* FDICT */
-	if ((hdr >> 5) & 1)
-		return LIBDEFLATE_BAD_DATA;
-
-	/* Compressed data  */
-	result = libdeflate_deflate_decompress_ex(d, in_next,
-					in_end - ZLIB_FOOTER_SIZE - in_next,
-					out, out_nbytes_avail,
-					&actual_in_nbytes, actual_out_nbytes_ret);
-	if (result != LIBDEFLATE_SUCCESS)
-		return result;
-
-	if (actual_out_nbytes_ret)
-		actual_out_nbytes = *actual_out_nbytes_ret;
-	else
-		actual_out_nbytes = out_nbytes_avail;
-
-	in_next += actual_in_nbytes;
-
-	/* ADLER32  */
-	if (libdeflate_adler32(1, out, actual_out_nbytes) !=
-	    get_unaligned_be32(in_next))
-		return LIBDEFLATE_BAD_DATA;
-	in_next += 4;
-
-	if (actual_in_nbytes_ret)
-		*actual_in_nbytes_ret = in_next - (u8 *)in;
-
-	return LIBDEFLATE_SUCCESS;
-}
-
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_zlib_decompress(struct libdeflate_decompressor *d,
-			   const void *in, size_t in_nbytes,
-			   void *out, size_t out_nbytes_avail,
-			   size_t *actual_out_nbytes_ret)
-{
-	return libdeflate_zlib_decompress_ex(d, in, in_nbytes,
-					     out, out_nbytes_avail,
-					     NULL, actual_out_nbytes_ret);
-}
diff --git a/vendor/core/vendor/libdeflate/libdeflate.h b/vendor/core/vendor/libdeflate/libdeflate.h
deleted file mode 100644
index 1821acda..00000000
--- a/vendor/core/vendor/libdeflate/libdeflate.h
+++ /dev/null
@@ -1,412 +0,0 @@
-/*
- * libdeflate.h - public header for libdeflate
- */
-
-#ifndef LIBDEFLATE_H
-#define LIBDEFLATE_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define LIBDEFLATE_VERSION_MAJOR	1
-#define LIBDEFLATE_VERSION_MINOR	26
-#define LIBDEFLATE_VERSION_STRING	"1.26"
-
-/*
- * Users of libdeflate.dll on Windows can define LIBDEFLATE_DLL to cause
- * __declspec(dllimport) to be used.  This should be done when it's easy to do.
- * Otherwise it's fine to skip it, since it is a very minor performance
- * optimization that is irrelevant for most use cases of libdeflate.
- */
-#ifndef LIBDEFLATEAPI
-#  if defined(LIBDEFLATE_DLL) && (defined(_WIN32) || defined(__CYGWIN__))
-#    define LIBDEFLATEAPI	__declspec(dllimport)
-#  else
-#    define LIBDEFLATEAPI
-#  endif
-#endif
-
-/* ========================================================================== */
-/*                             Compression                                    */
-/* ========================================================================== */
-
-struct libdeflate_compressor;
-struct libdeflate_options;
-
-/*
- * libdeflate_alloc_compressor() allocates a new compressor that supports
- * DEFLATE, zlib, and gzip compression.  'compression_level' is the compression
- * level on a zlib-like scale but with a higher maximum value (1 = fastest, 6 =
- * medium/default, 9 = slow, 12 = slowest).  Level 0 is also supported and means
- * "no compression", specifically "create a valid stream, but only emit
- * uncompressed blocks" (this will expand the data slightly).  Level -1 is an
- * alias indicating a default level of 6.
- *
- * The return value is a pointer to the new compressor, or NULL if out of memory
- * or if the compression level is invalid (i.e. outside the range [-1, 12]).
- *
- * Note: for compression, the sliding window size is defined at compilation time
- * to 32768, the largest size permissible in the DEFLATE format.  It cannot be
- * changed at runtime.
- *
- * A single compressor is not safe to use by multiple threads concurrently.
- * However, different threads may use different compressors concurrently.
- */
-LIBDEFLATEAPI struct libdeflate_compressor *
-libdeflate_alloc_compressor(int compression_level);
-
-/*
- * Like libdeflate_alloc_compressor(), but adds the 'options' argument.
- */
-LIBDEFLATEAPI struct libdeflate_compressor *
-libdeflate_alloc_compressor_ex(int compression_level,
-			       const struct libdeflate_options *options);
-
-/*
- * libdeflate_deflate_compress() performs raw DEFLATE compression on a buffer of
- * data.  It attempts to compress 'in_nbytes' bytes of data located at 'in' and
- * write the result to 'out', which has space for 'out_nbytes_avail' bytes.  The
- * return value is the compressed size in bytes, or 0 if the data could not be
- * compressed to 'out_nbytes_avail' bytes or fewer.
- *
- * If compression is successful, then the output data is guaranteed to be a
- * valid DEFLATE stream that decompresses to the input data.  No other
- * guarantees are made about the output data.  Notably, different versions of
- * libdeflate can produce different compressed data for the same uncompressed
- * data, even at the same compression level.  Do ***NOT*** do things like
- * writing tests that compare compressed data to a golden output, as this can
- * break when libdeflate is updated.  (This property isn't specific to
- * libdeflate; the same is true for zlib and other compression libraries too.)
- */
-LIBDEFLATEAPI size_t
-libdeflate_deflate_compress(struct libdeflate_compressor *compressor,
-			    const void *in, size_t in_nbytes,
-			    void *out, size_t out_nbytes_avail);
-
-/*
- * libdeflate_deflate_compress_bound() returns a worst-case upper bound on the
- * number of bytes of compressed data that may be produced by compressing any
- * buffer of length less than or equal to 'in_nbytes' using
- * libdeflate_deflate_compress() with the specified compressor.  This bound will
- * necessarily be a number greater than or equal to 'in_nbytes'.  It may be an
- * overestimate of the true upper bound.  The return value is guaranteed to be
- * the same for all invocations with the same compressor and same 'in_nbytes'.
- *
- * As a special case, 'compressor' may be NULL.  This causes the bound to be
- * taken across *any* libdeflate_compressor that could ever be allocated with
- * this build of the library, with any options.
- *
- * Note that this function is not necessary in many applications.  With
- * block-based compression, it is usually preferable to separately store the
- * uncompressed size of each block and to store any blocks that did not compress
- * to less than their original size uncompressed.  In that scenario, there is no
- * need to know the worst-case compressed size, since the maximum number of
- * bytes of compressed data that may be used would always be one less than the
- * input length.  You can just pass a buffer of that size to
- * libdeflate_deflate_compress() and store the data uncompressed if
- * libdeflate_deflate_compress() returns 0, indicating that the compressed data
- * did not fit into the provided output buffer.
- */
-LIBDEFLATEAPI size_t
-libdeflate_deflate_compress_bound(struct libdeflate_compressor *compressor,
-				  size_t in_nbytes);
-
-/*
- * Like libdeflate_deflate_compress(), but uses the zlib wrapper format instead
- * of raw DEFLATE.
- */
-LIBDEFLATEAPI size_t
-libdeflate_zlib_compress(struct libdeflate_compressor *compressor,
-			 const void *in, size_t in_nbytes,
-			 void *out, size_t out_nbytes_avail);
-
-/*
- * Like libdeflate_deflate_compress_bound(), but assumes the data will be
- * compressed with libdeflate_zlib_compress() rather than with
- * libdeflate_deflate_compress().
- */
-LIBDEFLATEAPI size_t
-libdeflate_zlib_compress_bound(struct libdeflate_compressor *compressor,
-			       size_t in_nbytes);
-
-/*
- * Like libdeflate_deflate_compress(), but uses the gzip wrapper format instead
- * of raw DEFLATE.
- */
-LIBDEFLATEAPI size_t
-libdeflate_gzip_compress(struct libdeflate_compressor *compressor,
-			 const void *in, size_t in_nbytes,
-			 void *out, size_t out_nbytes_avail);
-
-/*
- * Like libdeflate_deflate_compress_bound(), but assumes the data will be
- * compressed with libdeflate_gzip_compress() rather than with
- * libdeflate_deflate_compress().
- */
-LIBDEFLATEAPI size_t
-libdeflate_gzip_compress_bound(struct libdeflate_compressor *compressor,
-			       size_t in_nbytes);
-
-/*
- * libdeflate_free_compressor() frees a compressor that was allocated with
- * libdeflate_alloc_compressor().  If a NULL pointer is passed in, no action is
- * taken.
- */
-LIBDEFLATEAPI void
-libdeflate_free_compressor(struct libdeflate_compressor *compressor);
-
-/* ========================================================================== */
-/*                             Decompression                                  */
-/* ========================================================================== */
-
-struct libdeflate_decompressor;
-struct libdeflate_options;
-
-/*
- * libdeflate_alloc_decompressor() allocates a new decompressor that can be used
- * for DEFLATE, zlib, and gzip decompression.  The return value is a pointer to
- * the new decompressor, or NULL if out of memory.
- *
- * This function takes no parameters, and the returned decompressor is valid for
- * decompressing data that was compressed at any compression level and with any
- * sliding window size.
- *
- * A single decompressor is not safe to use by multiple threads concurrently.
- * However, different threads may use different decompressors concurrently.
- */
-LIBDEFLATEAPI struct libdeflate_decompressor *
-libdeflate_alloc_decompressor(void);
-
-/*
- * Like libdeflate_alloc_decompressor(), but adds the 'options' argument.
- */
-LIBDEFLATEAPI struct libdeflate_decompressor *
-libdeflate_alloc_decompressor_ex(const struct libdeflate_options *options);
-
-/*
- * Result of a call to libdeflate_deflate_decompress(),
- * libdeflate_zlib_decompress(), or libdeflate_gzip_decompress().
- */
-enum libdeflate_result {
-	/* Decompression was successful.  */
-	LIBDEFLATE_SUCCESS = 0,
-
-	/* Decompression failed because the compressed data was invalid,
-	 * corrupt, or otherwise unsupported.  */
-	LIBDEFLATE_BAD_DATA = 1,
-
-	/* A NULL 'actual_out_nbytes_ret' was provided, but the data would have
-	 * decompressed to fewer than 'out_nbytes_avail' bytes.  */
-	LIBDEFLATE_SHORT_OUTPUT = 2,
-
-	/* The data would have decompressed to more than 'out_nbytes_avail'
-	 * bytes.  */
-	LIBDEFLATE_INSUFFICIENT_SPACE = 3,
-};
-
-/*
- * libdeflate_deflate_decompress() decompresses a DEFLATE stream from the buffer
- * 'in' with compressed size up to 'in_nbytes' bytes.  The uncompressed data is
- * written to 'out', a buffer with size 'out_nbytes_avail' bytes.  If
- * decompression succeeds, then 0 (LIBDEFLATE_SUCCESS) is returned.  Otherwise,
- * a nonzero result code such as LIBDEFLATE_BAD_DATA is returned, and the
- * contents of the output buffer are undefined.
- *
- * Decompression stops at the end of the DEFLATE stream (as indicated by the
- * BFINAL flag), even if it is actually shorter than 'in_nbytes' bytes.
- *
- * libdeflate_deflate_decompress() can be used in cases where the actual
- * uncompressed size is known (recommended) or unknown (not recommended):
- *
- *   - If the actual uncompressed size is known, then pass the actual
- *     uncompressed size as 'out_nbytes_avail' and pass NULL for
- *     'actual_out_nbytes_ret'.  This makes libdeflate_deflate_decompress() fail
- *     with LIBDEFLATE_SHORT_OUTPUT if the data decompressed to fewer than the
- *     specified number of bytes.
- *
- *   - If the actual uncompressed size is unknown, then provide a non-NULL
- *     'actual_out_nbytes_ret' and provide a buffer with some size
- *     'out_nbytes_avail' that you think is large enough to hold all the
- *     uncompressed data.  In this case, if the data decompresses to less than
- *     or equal to 'out_nbytes_avail' bytes, then
- *     libdeflate_deflate_decompress() will write the actual uncompressed size
- *     to *actual_out_nbytes_ret and return 0 (LIBDEFLATE_SUCCESS).  Otherwise,
- *     it will return LIBDEFLATE_INSUFFICIENT_SPACE if the provided buffer was
- *     not large enough but no other problems were encountered, or another
- *     nonzero result code if decompression failed for another reason.
- */
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_deflate_decompress(struct libdeflate_decompressor *decompressor,
-			      const void *in, size_t in_nbytes,
-			      void *out, size_t out_nbytes_avail,
-			      size_t *actual_out_nbytes_ret);
-
-/*
- * Like libdeflate_deflate_decompress(), but adds the 'actual_in_nbytes_ret'
- * argument.  If decompression succeeds and 'actual_in_nbytes_ret' is not NULL,
- * then the actual compressed size of the DEFLATE stream (aligned to the next
- * byte boundary) is written to *actual_in_nbytes_ret.
- */
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_deflate_decompress_ex(struct libdeflate_decompressor *decompressor,
-				 const void *in, size_t in_nbytes,
-				 void *out, size_t out_nbytes_avail,
-				 size_t *actual_in_nbytes_ret,
-				 size_t *actual_out_nbytes_ret);
-
-/*
- * Like libdeflate_deflate_decompress(), but assumes the zlib wrapper format
- * instead of raw DEFLATE.
- *
- * Decompression will stop at the end of the zlib stream, even if it is shorter
- * than 'in_nbytes'.  If you need to know exactly where the zlib stream ended,
- * use libdeflate_zlib_decompress_ex().
- */
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_zlib_decompress(struct libdeflate_decompressor *decompressor,
-			   const void *in, size_t in_nbytes,
-			   void *out, size_t out_nbytes_avail,
-			   size_t *actual_out_nbytes_ret);
-
-/*
- * Like libdeflate_zlib_decompress(), but adds the 'actual_in_nbytes_ret'
- * argument.  If 'actual_in_nbytes_ret' is not NULL and the decompression
- * succeeds (indicating that the first zlib-compressed stream in the input
- * buffer was decompressed), then the actual number of input bytes consumed is
- * written to *actual_in_nbytes_ret.
- */
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_zlib_decompress_ex(struct libdeflate_decompressor *decompressor,
-			      const void *in, size_t in_nbytes,
-			      void *out, size_t out_nbytes_avail,
-			      size_t *actual_in_nbytes_ret,
-			      size_t *actual_out_nbytes_ret);
-
-/*
- * Like libdeflate_deflate_decompress(), but assumes the gzip wrapper format
- * instead of raw DEFLATE.
- *
- * If multiple gzip-compressed members are concatenated, then only the first
- * will be decompressed.  Use libdeflate_gzip_decompress_ex() if you need
- * multi-member support.
- */
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_gzip_decompress(struct libdeflate_decompressor *decompressor,
-			   const void *in, size_t in_nbytes,
-			   void *out, size_t out_nbytes_avail,
-			   size_t *actual_out_nbytes_ret);
-
-/*
- * Like libdeflate_gzip_decompress(), but adds the 'actual_in_nbytes_ret'
- * argument.  If 'actual_in_nbytes_ret' is not NULL and the decompression
- * succeeds (indicating that the first gzip-compressed member in the input
- * buffer was decompressed), then the actual number of input bytes consumed is
- * written to *actual_in_nbytes_ret.
- */
-LIBDEFLATEAPI enum libdeflate_result
-libdeflate_gzip_decompress_ex(struct libdeflate_decompressor *decompressor,
-			      const void *in, size_t in_nbytes,
-			      void *out, size_t out_nbytes_avail,
-			      size_t *actual_in_nbytes_ret,
-			      size_t *actual_out_nbytes_ret);
-
-/*
- * libdeflate_free_decompressor() frees a decompressor that was allocated with
- * libdeflate_alloc_decompressor().  If a NULL pointer is passed in, no action
- * is taken.
- */
-LIBDEFLATEAPI void
-libdeflate_free_decompressor(struct libdeflate_decompressor *decompressor);
-
-/* ========================================================================== */
-/*                                Checksums                                   */
-/* ========================================================================== */
-
-/*
- * libdeflate_adler32() updates a running Adler-32 checksum with 'len' bytes of
- * data and returns the updated checksum.  When starting a new checksum, the
- * required initial value for 'adler' is 1.  This value is also returned when
- * 'buffer' is specified as NULL.
- */
-LIBDEFLATEAPI uint32_t
-libdeflate_adler32(uint32_t adler, const void *buffer, size_t len);
-
-
-/*
- * libdeflate_crc32() updates a running CRC-32 checksum with 'len' bytes of data
- * and returns the updated checksum.  When starting a new checksum, the required
- * initial value for 'crc' is 0.  This value is also returned when 'buffer' is
- * specified as NULL.
- */
-LIBDEFLATEAPI uint32_t
-libdeflate_crc32(uint32_t crc, const void *buffer, size_t len);
-
-/* ========================================================================== */
-/*                           Custom memory allocator                          */
-/* ========================================================================== */
-
-/*
- * Install a custom memory allocator which libdeflate will use for all memory
- * allocations by default.  'malloc_func' is a function that must behave like
- * malloc(), and 'free_func' is a function that must behave like free().
- *
- * The per-(de)compressor custom memory allocator that can be specified in
- * 'struct libdeflate_options' takes priority over this.
- *
- * This doesn't affect the free() function that will be used to free
- * (de)compressors that were already in existence when this is called.
- */
-LIBDEFLATEAPI void
-libdeflate_set_memory_allocator(void *(*malloc_func)(size_t),
-				void (*free_func)(void *));
-
-/*
- * Advanced options.  This is the options structure that
- * libdeflate_alloc_compressor_ex() and libdeflate_alloc_decompressor_ex()
- * require.  Most users won't need this and should just use the non-"_ex"
- * functions instead.  If you do need this, it should be initialized like this:
- *
- *	struct libdeflate_options options;
- *
- *	memset(&options, 0, sizeof(options));
- *	options.sizeof_options = sizeof(options);
- *	// Then set the fields that you need to override the defaults for.
- */
-struct libdeflate_options {
-
-	/*
-	 * This field must be set to the struct size.  This field exists for
-	 * extensibility, so that fields can be appended to this struct in
-	 * future versions of libdeflate while still supporting old binaries.
-	 */
-	size_t sizeof_options;
-
-	/*
-	 * An optional custom memory allocator to use for this (de)compressor.
-	 * 'malloc_func' must be a function that behaves like malloc(), and
-	 * 'free_func' must be a function that behaves like free().
-	 *
-	 * This is useful in cases where a process might have multiple users of
-	 * libdeflate who want to use different memory allocators.  For example,
-	 * a library might want to use libdeflate with a custom memory allocator
-	 * without interfering with user code that might use libdeflate too.
-	 *
-	 * This takes priority over the "global" memory allocator (which by
-	 * default is malloc() and free(), but can be changed by
-	 * libdeflate_set_memory_allocator()).  Moreover, libdeflate will never
-	 * call the "global" memory allocator if a per-(de)compressor custom
-	 * allocator is always given.
-	 */
-	void *(*malloc_func)(size_t);
-	void (*free_func)(void *);
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBDEFLATE_H */
diff --git a/vendor/core/vendor/unicodetools/unicodetools/data/ucd/dev/CaseFolding.txt b/vendor/core/vendor/unicodetools/unicodetools/data/ucd/dev/CaseFolding.txt
new file mode 100644
index 00000000..a0b0f07f
--- /dev/null
+++ b/vendor/core/vendor/unicodetools/unicodetools/data/ucd/dev/CaseFolding.txt
@@ -0,0 +1,1682 @@
+# CaseFolding-17.0.0.txt
+# Date: 2025-07-30, 23:54:36 GMT
+# © 2025 Unicode®, Inc.
+# Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
+# For terms of use and license, see https://www.unicode.org/terms_of_use.html
+#
+# Unicode Character Database
+#   For documentation, see https://www.unicode.org/reports/tr44/
+#
+# Case Folding Properties
+#
+# This file is a supplement to the UnicodeData file.
+# It provides a case folding mapping generated from the Unicode Character Database.
+# If all characters are mapped according to the full mapping below, then
+# case differences (according to UnicodeData.txt and SpecialCasing.txt)
+# are eliminated.
+#
+# The data supports both implementations that require simple case foldings
+# (where string lengths don't change), and implementations that allow full case folding
+# (where string lengths may grow). Note that where they can be supported, the
+# full case foldings are superior: for example, they allow "FUSS" and "Fuß" to match.
+#
+# All code points not listed in this file map to themselves.
+#
+# NOTE: case folding does not preserve normalization formats!
+#
+# For information on case folding, including how to have case folding
+# preserve normalization formats, see the
+# "Conformance" / "Default Case Algorithms" section of the core specification.
+#
+# ================================================================================
+# Format
+# ================================================================================
+# The entries in this file are in the following machine-readable format:
+#
+# <code>; <status>; <mapping>; # <name>
+#
+# The status field is:
+# C: common case folding, common mappings shared by both simple and full mappings.
+# F: full case folding, mappings that cause strings to grow in length. Multiple characters are separated by spaces.
+# S: simple case folding, mappings to single characters where different from F.
+# T: special case for uppercase I and dotted uppercase I
+#    - For non-Turkic languages, this mapping is normally not used.
+#    - For Turkic languages (tr, az), this mapping can be used instead of the normal mapping for these characters.
+#      Note that the Turkic mappings do not maintain canonical equivalence without additional processing.
+#      See the discussions of case mapping in the Unicode Standard for more information.
+#
+# Usage:
+#  A. To do a simple case folding, use the mappings with status C + S.
+#  B. To do a full case folding, use the mappings with status C + F.
+#
+#    The mappings with status T can be used or omitted depending on the desired case-folding
+#    behavior. (The default option is to exclude them.)
+#
+# =================================================================
+
+# Property: Case_Folding
+
+#  All code points not explicitly listed for Case_Folding
+#  have the value C for the status field, and the code point itself for the mapping field.
+
+# =================================================================
+0041; C; 0061; # LATIN CAPITAL LETTER A
+0042; C; 0062; # LATIN CAPITAL LETTER B
+0043; C; 0063; # LATIN CAPITAL LETTER C
+0044; C; 0064; # LATIN CAPITAL LETTER D
+0045; C; 0065; # LATIN CAPITAL LETTER E
+0046; C; 0066; # LATIN CAPITAL LETTER F
+0047; C; 0067; # LATIN CAPITAL LETTER G
+0048; C; 0068; # LATIN CAPITAL LETTER H
+0049; C; 0069; # LATIN CAPITAL LETTER I
+0049; T; 0131; # LATIN CAPITAL LETTER I
+004A; C; 006A; # LATIN CAPITAL LETTER J
+004B; C; 006B; # LATIN CAPITAL LETTER K
+004C; C; 006C; # LATIN CAPITAL LETTER L
+004D; C; 006D; # LATIN CAPITAL LETTER M
+004E; C; 006E; # LATIN CAPITAL LETTER N
+004F; C; 006F; # LATIN CAPITAL LETTER O
+0050; C; 0070; # LATIN CAPITAL LETTER P
+0051; C; 0071; # LATIN CAPITAL LETTER Q
+0052; C; 0072; # LATIN CAPITAL LETTER R
+0053; C; 0073; # LATIN CAPITAL LETTER S
+0054; C; 0074; # LATIN CAPITAL LETTER T
+0055; C; 0075; # LATIN CAPITAL LETTER U
+0056; C; 0076; # LATIN CAPITAL LETTER V
+0057; C; 0077; # LATIN CAPITAL LETTER W
+0058; C; 0078; # LATIN CAPITAL LETTER X
+0059; C; 0079; # LATIN CAPITAL LETTER Y
+005A; C; 007A; # LATIN CAPITAL LETTER Z
+00B5; C; 03BC; # MICRO SIGN
+00C0; C; 00E0; # LATIN CAPITAL LETTER A WITH GRAVE
+00C1; C; 00E1; # LATIN CAPITAL LETTER A WITH ACUTE
+00C2; C; 00E2; # LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+00C3; C; 00E3; # LATIN CAPITAL LETTER A WITH TILDE
+00C4; C; 00E4; # LATIN CAPITAL LETTER A WITH DIAERESIS
+00C5; C; 00E5; # LATIN CAPITAL LETTER A WITH RING ABOVE
+00C6; C; 00E6; # LATIN CAPITAL LETTER AE
+00C7; C; 00E7; # LATIN CAPITAL LETTER C WITH CEDILLA
+00C8; C; 00E8; # LATIN CAPITAL LETTER E WITH GRAVE
+00C9; C; 00E9; # LATIN CAPITAL LETTER E WITH ACUTE
+00CA; C; 00EA; # LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+00CB; C; 00EB; # LATIN CAPITAL LETTER E WITH DIAERESIS
+00CC; C; 00EC; # LATIN CAPITAL LETTER I WITH GRAVE
+00CD; C; 00ED; # LATIN CAPITAL LETTER I WITH ACUTE
+00CE; C; 00EE; # LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+00CF; C; 00EF; # LATIN CAPITAL LETTER I WITH DIAERESIS
+00D0; C; 00F0; # LATIN CAPITAL LETTER ETH
+00D1; C; 00F1; # LATIN CAPITAL LETTER N WITH TILDE
+00D2; C; 00F2; # LATIN CAPITAL LETTER O WITH GRAVE
+00D3; C; 00F3; # LATIN CAPITAL LETTER O WITH ACUTE
+00D4; C; 00F4; # LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+00D5; C; 00F5; # LATIN CAPITAL LETTER O WITH TILDE
+00D6; C; 00F6; # LATIN CAPITAL LETTER O WITH DIAERESIS
+00D8; C; 00F8; # LATIN CAPITAL LETTER O WITH STROKE
+00D9; C; 00F9; # LATIN CAPITAL LETTER U WITH GRAVE
+00DA; C; 00FA; # LATIN CAPITAL LETTER U WITH ACUTE
+00DB; C; 00FB; # LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+00DC; C; 00FC; # LATIN CAPITAL LETTER U WITH DIAERESIS
+00DD; C; 00FD; # LATIN CAPITAL LETTER Y WITH ACUTE
+00DE; C; 00FE; # LATIN CAPITAL LETTER THORN
+00DF; F; 0073 0073; # LATIN SMALL LETTER SHARP S
+0100; C; 0101; # LATIN CAPITAL LETTER A WITH MACRON
+0102; C; 0103; # LATIN CAPITAL LETTER A WITH BREVE
+0104; C; 0105; # LATIN CAPITAL LETTER A WITH OGONEK
+0106; C; 0107; # LATIN CAPITAL LETTER C WITH ACUTE
+0108; C; 0109; # LATIN CAPITAL LETTER C WITH CIRCUMFLEX
+010A; C; 010B; # LATIN CAPITAL LETTER C WITH DOT ABOVE
+010C; C; 010D; # LATIN CAPITAL LETTER C WITH CARON
+010E; C; 010F; # LATIN CAPITAL LETTER D WITH CARON
+0110; C; 0111; # LATIN CAPITAL LETTER D WITH STROKE
+0112; C; 0113; # LATIN CAPITAL LETTER E WITH MACRON
+0114; C; 0115; # LATIN CAPITAL LETTER E WITH BREVE
+0116; C; 0117; # LATIN CAPITAL LETTER E WITH DOT ABOVE
+0118; C; 0119; # LATIN CAPITAL LETTER E WITH OGONEK
+011A; C; 011B; # LATIN CAPITAL LETTER E WITH CARON
+011C; C; 011D; # LATIN CAPITAL LETTER G WITH CIRCUMFLEX
+011E; C; 011F; # LATIN CAPITAL LETTER G WITH BREVE
+0120; C; 0121; # LATIN CAPITAL LETTER G WITH DOT ABOVE
+0122; C; 0123; # LATIN CAPITAL LETTER G WITH CEDILLA
+0124; C; 0125; # LATIN CAPITAL LETTER H WITH CIRCUMFLEX
+0126; C; 0127; # LATIN CAPITAL LETTER H WITH STROKE
+0128; C; 0129; # LATIN CAPITAL LETTER I WITH TILDE
+012A; C; 012B; # LATIN CAPITAL LETTER I WITH MACRON
+012C; C; 012D; # LATIN CAPITAL LETTER I WITH BREVE
+012E; C; 012F; # LATIN CAPITAL LETTER I WITH OGONEK
+0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+0132; C; 0133; # LATIN CAPITAL LIGATURE IJ
+0134; C; 0135; # LATIN CAPITAL LETTER J WITH CIRCUMFLEX
+0136; C; 0137; # LATIN CAPITAL LETTER K WITH CEDILLA
+0139; C; 013A; # LATIN CAPITAL LETTER L WITH ACUTE
+013B; C; 013C; # LATIN CAPITAL LETTER L WITH CEDILLA
+013D; C; 013E; # LATIN CAPITAL LETTER L WITH CARON
+013F; C; 0140; # LATIN CAPITAL LETTER L WITH MIDDLE DOT
+0141; C; 0142; # LATIN CAPITAL LETTER L WITH STROKE
+0143; C; 0144; # LATIN CAPITAL LETTER N WITH ACUTE
+0145; C; 0146; # LATIN CAPITAL LETTER N WITH CEDILLA
+0147; C; 0148; # LATIN CAPITAL LETTER N WITH CARON
+0149; F; 02BC 006E; # LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+014A; C; 014B; # LATIN CAPITAL LETTER ENG
+014C; C; 014D; # LATIN CAPITAL LETTER O WITH MACRON
+014E; C; 014F; # LATIN CAPITAL LETTER O WITH BREVE
+0150; C; 0151; # LATIN CAPITAL LETTER O WITH DOUBLE ACUTE
+0152; C; 0153; # LATIN CAPITAL LIGATURE OE
+0154; C; 0155; # LATIN CAPITAL LETTER R WITH ACUTE
+0156; C; 0157; # LATIN CAPITAL LETTER R WITH CEDILLA
+0158; C; 0159; # LATIN CAPITAL LETTER R WITH CARON
+015A; C; 015B; # LATIN CAPITAL LETTER S WITH ACUTE
+015C; C; 015D; # LATIN CAPITAL LETTER S WITH CIRCUMFLEX
+015E; C; 015F; # LATIN CAPITAL LETTER S WITH CEDILLA
+0160; C; 0161; # LATIN CAPITAL LETTER S WITH CARON
+0162; C; 0163; # LATIN CAPITAL LETTER T WITH CEDILLA
+0164; C; 0165; # LATIN CAPITAL LETTER T WITH CARON
+0166; C; 0167; # LATIN CAPITAL LETTER T WITH STROKE
+0168; C; 0169; # LATIN CAPITAL LETTER U WITH TILDE
+016A; C; 016B; # LATIN CAPITAL LETTER U WITH MACRON
+016C; C; 016D; # LATIN CAPITAL LETTER U WITH BREVE
+016E; C; 016F; # LATIN CAPITAL LETTER U WITH RING ABOVE
+0170; C; 0171; # LATIN CAPITAL LETTER U WITH DOUBLE ACUTE
+0172; C; 0173; # LATIN CAPITAL LETTER U WITH OGONEK
+0174; C; 0175; # LATIN CAPITAL LETTER W WITH CIRCUMFLEX
+0176; C; 0177; # LATIN CAPITAL LETTER Y WITH CIRCUMFLEX
+0178; C; 00FF; # LATIN CAPITAL LETTER Y WITH DIAERESIS
+0179; C; 017A; # LATIN CAPITAL LETTER Z WITH ACUTE
+017B; C; 017C; # LATIN CAPITAL LETTER Z WITH DOT ABOVE
+017D; C; 017E; # LATIN CAPITAL LETTER Z WITH CARON
+017F; C; 0073; # LATIN SMALL LETTER LONG S
+0181; C; 0253; # LATIN CAPITAL LETTER B WITH HOOK
+0182; C; 0183; # LATIN CAPITAL LETTER B WITH TOPBAR
+0184; C; 0185; # LATIN CAPITAL LETTER TONE SIX
+0186; C; 0254; # LATIN CAPITAL LETTER OPEN O
+0187; C; 0188; # LATIN CAPITAL LETTER C WITH HOOK
+0189; C; 0256; # LATIN CAPITAL LETTER AFRICAN D
+018A; C; 0257; # LATIN CAPITAL LETTER D WITH HOOK
+018B; C; 018C; # LATIN CAPITAL LETTER D WITH TOPBAR
+018E; C; 01DD; # LATIN CAPITAL LETTER REVERSED E
+018F; C; 0259; # LATIN CAPITAL LETTER SCHWA
+0190; C; 025B; # LATIN CAPITAL LETTER OPEN E
+0191; C; 0192; # LATIN CAPITAL LETTER F WITH HOOK
+0193; C; 0260; # LATIN CAPITAL LETTER G WITH HOOK
+0194; C; 0263; # LATIN CAPITAL LETTER GAMMA
+0196; C; 0269; # LATIN CAPITAL LETTER IOTA
+0197; C; 0268; # LATIN CAPITAL LETTER I WITH STROKE
+0198; C; 0199; # LATIN CAPITAL LETTER K WITH HOOK
+019C; C; 026F; # LATIN CAPITAL LETTER TURNED M
+019D; C; 0272; # LATIN CAPITAL LETTER N WITH LEFT HOOK
+019F; C; 0275; # LATIN CAPITAL LETTER O WITH MIDDLE TILDE
+01A0; C; 01A1; # LATIN CAPITAL LETTER O WITH HORN
+01A2; C; 01A3; # LATIN CAPITAL LETTER OI
+01A4; C; 01A5; # LATIN CAPITAL LETTER P WITH HOOK
+01A6; C; 0280; # LATIN LETTER YR
+01A7; C; 01A8; # LATIN CAPITAL LETTER TONE TWO
+01A9; C; 0283; # LATIN CAPITAL LETTER ESH
+01AC; C; 01AD; # LATIN CAPITAL LETTER T WITH HOOK
+01AE; C; 0288; # LATIN CAPITAL LETTER T WITH RETROFLEX HOOK
+01AF; C; 01B0; # LATIN CAPITAL LETTER U WITH HORN
+01B1; C; 028A; # LATIN CAPITAL LETTER UPSILON
+01B2; C; 028B; # LATIN CAPITAL LETTER V WITH HOOK
+01B3; C; 01B4; # LATIN CAPITAL LETTER Y WITH HOOK
+01B5; C; 01B6; # LATIN CAPITAL LETTER Z WITH STROKE
+01B7; C; 0292; # LATIN CAPITAL LETTER EZH
+01B8; C; 01B9; # LATIN CAPITAL LETTER EZH REVERSED
+01BC; C; 01BD; # LATIN CAPITAL LETTER TONE FIVE
+01C4; C; 01C6; # LATIN CAPITAL LETTER DZ WITH CARON
+01C5; C; 01C6; # LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
+01C7; C; 01C9; # LATIN CAPITAL LETTER LJ
+01C8; C; 01C9; # LATIN CAPITAL LETTER L WITH SMALL LETTER J
+01CA; C; 01CC; # LATIN CAPITAL LETTER NJ
+01CB; C; 01CC; # LATIN CAPITAL LETTER N WITH SMALL LETTER J
+01CD; C; 01CE; # LATIN CAPITAL LETTER A WITH CARON
+01CF; C; 01D0; # LATIN CAPITAL LETTER I WITH CARON
+01D1; C; 01D2; # LATIN CAPITAL LETTER O WITH CARON
+01D3; C; 01D4; # LATIN CAPITAL LETTER U WITH CARON
+01D5; C; 01D6; # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON
+01D7; C; 01D8; # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE
+01D9; C; 01DA; # LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON
+01DB; C; 01DC; # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE
+01DE; C; 01DF; # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON
+01E0; C; 01E1; # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON
+01E2; C; 01E3; # LATIN CAPITAL LETTER AE WITH MACRON
+01E4; C; 01E5; # LATIN CAPITAL LETTER G WITH STROKE
+01E6; C; 01E7; # LATIN CAPITAL LETTER G WITH CARON
+01E8; C; 01E9; # LATIN CAPITAL LETTER K WITH CARON
+01EA; C; 01EB; # LATIN CAPITAL LETTER O WITH OGONEK
+01EC; C; 01ED; # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON
+01EE; C; 01EF; # LATIN CAPITAL LETTER EZH WITH CARON
+01F0; F; 006A 030C; # LATIN SMALL LETTER J WITH CARON
+01F1; C; 01F3; # LATIN CAPITAL LETTER DZ
+01F2; C; 01F3; # LATIN CAPITAL LETTER D WITH SMALL LETTER Z
+01F4; C; 01F5; # LATIN CAPITAL LETTER G WITH ACUTE
+01F6; C; 0195; # LATIN CAPITAL LETTER HWAIR
+01F7; C; 01BF; # LATIN CAPITAL LETTER WYNN
+01F8; C; 01F9; # LATIN CAPITAL LETTER N WITH GRAVE
+01FA; C; 01FB; # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE
+01FC; C; 01FD; # LATIN CAPITAL LETTER AE WITH ACUTE
+01FE; C; 01FF; # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE
+0200; C; 0201; # LATIN CAPITAL LETTER A WITH DOUBLE GRAVE
+0202; C; 0203; # LATIN CAPITAL LETTER A WITH INVERTED BREVE
+0204; C; 0205; # LATIN CAPITAL LETTER E WITH DOUBLE GRAVE
+0206; C; 0207; # LATIN CAPITAL LETTER E WITH INVERTED BREVE
+0208; C; 0209; # LATIN CAPITAL LETTER I WITH DOUBLE GRAVE
+020A; C; 020B; # LATIN CAPITAL LETTER I WITH INVERTED BREVE
+020C; C; 020D; # LATIN CAPITAL LETTER O WITH DOUBLE GRAVE
+020E; C; 020F; # LATIN CAPITAL LETTER O WITH INVERTED BREVE
+0210; C; 0211; # LATIN CAPITAL LETTER R WITH DOUBLE GRAVE
+0212; C; 0213; # LATIN CAPITAL LETTER R WITH INVERTED BREVE
+0214; C; 0215; # LATIN CAPITAL LETTER U WITH DOUBLE GRAVE
+0216; C; 0217; # LATIN CAPITAL LETTER U WITH INVERTED BREVE
+0218; C; 0219; # LATIN CAPITAL LETTER S WITH COMMA BELOW
+021A; C; 021B; # LATIN CAPITAL LETTER T WITH COMMA BELOW
+021C; C; 021D; # LATIN CAPITAL LETTER YOGH
+021E; C; 021F; # LATIN CAPITAL LETTER H WITH CARON
+0220; C; 019E; # LATIN CAPITAL LETTER N WITH LONG RIGHT LEG
+0222; C; 0223; # LATIN CAPITAL LETTER OU
+0224; C; 0225; # LATIN CAPITAL LETTER Z WITH HOOK
+0226; C; 0227; # LATIN CAPITAL LETTER A WITH DOT ABOVE
+0228; C; 0229; # LATIN CAPITAL LETTER E WITH CEDILLA
+022A; C; 022B; # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON
+022C; C; 022D; # LATIN CAPITAL LETTER O WITH TILDE AND MACRON
+022E; C; 022F; # LATIN CAPITAL LETTER O WITH DOT ABOVE
+0230; C; 0231; # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON
+0232; C; 0233; # LATIN CAPITAL LETTER Y WITH MACRON
+023A; C; 2C65; # LATIN CAPITAL LETTER A WITH STROKE
+023B; C; 023C; # LATIN CAPITAL LETTER C WITH STROKE
+023D; C; 019A; # LATIN CAPITAL LETTER L WITH BAR
+023E; C; 2C66; # LATIN CAPITAL LETTER T WITH DIAGONAL STROKE
+0241; C; 0242; # LATIN CAPITAL LETTER GLOTTAL STOP
+0243; C; 0180; # LATIN CAPITAL LETTER B WITH STROKE
+0244; C; 0289; # LATIN CAPITAL LETTER U BAR
+0245; C; 028C; # LATIN CAPITAL LETTER TURNED V
+0246; C; 0247; # LATIN CAPITAL LETTER E WITH STROKE
+0248; C; 0249; # LATIN CAPITAL LETTER J WITH STROKE
+024A; C; 024B; # LATIN CAPITAL LETTER SMALL Q WITH HOOK TAIL
+024C; C; 024D; # LATIN CAPITAL LETTER R WITH STROKE
+024E; C; 024F; # LATIN CAPITAL LETTER Y WITH STROKE
+0345; C; 03B9; # COMBINING GREEK YPOGEGRAMMENI
+0370; C; 0371; # GREEK CAPITAL LETTER HETA
+0372; C; 0373; # GREEK CAPITAL LETTER ARCHAIC SAMPI
+0376; C; 0377; # GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA
+037F; C; 03F3; # GREEK CAPITAL LETTER YOT
+0386; C; 03AC; # GREEK CAPITAL LETTER ALPHA WITH TONOS
+0388; C; 03AD; # GREEK CAPITAL LETTER EPSILON WITH TONOS
+0389; C; 03AE; # GREEK CAPITAL LETTER ETA WITH TONOS
+038A; C; 03AF; # GREEK CAPITAL LETTER IOTA WITH TONOS
+038C; C; 03CC; # GREEK CAPITAL LETTER OMICRON WITH TONOS
+038E; C; 03CD; # GREEK CAPITAL LETTER UPSILON WITH TONOS
+038F; C; 03CE; # GREEK CAPITAL LETTER OMEGA WITH TONOS
+0390; F; 03B9 0308 0301; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+0391; C; 03B1; # GREEK CAPITAL LETTER ALPHA
+0392; C; 03B2; # GREEK CAPITAL LETTER BETA
+0393; C; 03B3; # GREEK CAPITAL LETTER GAMMA
+0394; C; 03B4; # GREEK CAPITAL LETTER DELTA
+0395; C; 03B5; # GREEK CAPITAL LETTER EPSILON
+0396; C; 03B6; # GREEK CAPITAL LETTER ZETA
+0397; C; 03B7; # GREEK CAPITAL LETTER ETA
+0398; C; 03B8; # GREEK CAPITAL LETTER THETA
+0399; C; 03B9; # GREEK CAPITAL LETTER IOTA
+039A; C; 03BA; # GREEK CAPITAL LETTER KAPPA
+039B; C; 03BB; # GREEK CAPITAL LETTER LAMDA
+039C; C; 03BC; # GREEK CAPITAL LETTER MU
+039D; C; 03BD; # GREEK CAPITAL LETTER NU
+039E; C; 03BE; # GREEK CAPITAL LETTER XI
+039F; C; 03BF; # GREEK CAPITAL LETTER OMICRON
+03A0; C; 03C0; # GREEK CAPITAL LETTER PI
+03A1; C; 03C1; # GREEK CAPITAL LETTER RHO
+03A3; C; 03C3; # GREEK CAPITAL LETTER SIGMA
+03A4; C; 03C4; # GREEK CAPITAL LETTER TAU
+03A5; C; 03C5; # GREEK CAPITAL LETTER UPSILON
+03A6; C; 03C6; # GREEK CAPITAL LETTER PHI
+03A7; C; 03C7; # GREEK CAPITAL LETTER CHI
+03A8; C; 03C8; # GREEK CAPITAL LETTER PSI
+03A9; C; 03C9; # GREEK CAPITAL LETTER OMEGA
+03AA; C; 03CA; # GREEK CAPITAL LETTER IOTA WITH DIALYTIKA
+03AB; C; 03CB; # GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA
+03B0; F; 03C5 0308 0301; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+03C2; C; 03C3; # GREEK SMALL LETTER FINAL SIGMA
+03CF; C; 03D7; # GREEK CAPITAL KAI SYMBOL
+03D0; C; 03B2; # GREEK BETA SYMBOL
+03D1; C; 03B8; # GREEK THETA SYMBOL
+03D5; C; 03C6; # GREEK PHI SYMBOL
+03D6; C; 03C0; # GREEK PI SYMBOL
+03D8; C; 03D9; # GREEK LETTER ARCHAIC KOPPA
+03DA; C; 03DB; # GREEK LETTER STIGMA
+03DC; C; 03DD; # GREEK LETTER DIGAMMA
+03DE; C; 03DF; # GREEK LETTER KOPPA
+03E0; C; 03E1; # GREEK LETTER SAMPI
+03E2; C; 03E3; # COPTIC CAPITAL LETTER SHEI
+03E4; C; 03E5; # COPTIC CAPITAL LETTER FEI
+03E6; C; 03E7; # COPTIC CAPITAL LETTER KHEI
+03E8; C; 03E9; # COPTIC CAPITAL LETTER HORI
+03EA; C; 03EB; # COPTIC CAPITAL LETTER GANGIA
+03EC; C; 03ED; # COPTIC CAPITAL LETTER SHIMA
+03EE; C; 03EF; # COPTIC CAPITAL LETTER DEI
+03F0; C; 03BA; # GREEK KAPPA SYMBOL
+03F1; C; 03C1; # GREEK RHO SYMBOL
+03F4; C; 03B8; # GREEK CAPITAL THETA SYMBOL
+03F5; C; 03B5; # GREEK LUNATE EPSILON SYMBOL
+03F7; C; 03F8; # GREEK CAPITAL LETTER SHO
+03F9; C; 03F2; # GREEK CAPITAL LUNATE SIGMA SYMBOL
+03FA; C; 03FB; # GREEK CAPITAL LETTER SAN
+03FD; C; 037B; # GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL
+03FE; C; 037C; # GREEK CAPITAL DOTTED LUNATE SIGMA SYMBOL
+03FF; C; 037D; # GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL
+0400; C; 0450; # CYRILLIC CAPITAL LETTER IE WITH GRAVE
+0401; C; 0451; # CYRILLIC CAPITAL LETTER IO
+0402; C; 0452; # CYRILLIC CAPITAL LETTER DJE
+0403; C; 0453; # CYRILLIC CAPITAL LETTER GJE
+0404; C; 0454; # CYRILLIC CAPITAL LETTER UKRAINIAN IE
+0405; C; 0455; # CYRILLIC CAPITAL LETTER DZE
+0406; C; 0456; # CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I
+0407; C; 0457; # CYRILLIC CAPITAL LETTER YI
+0408; C; 0458; # CYRILLIC CAPITAL LETTER JE
+0409; C; 0459; # CYRILLIC CAPITAL LETTER LJE
+040A; C; 045A; # CYRILLIC CAPITAL LETTER NJE
+040B; C; 045B; # CYRILLIC CAPITAL LETTER TSHE
+040C; C; 045C; # CYRILLIC CAPITAL LETTER KJE
+040D; C; 045D; # CYRILLIC CAPITAL LETTER I WITH GRAVE
+040E; C; 045E; # CYRILLIC CAPITAL LETTER SHORT U
+040F; C; 045F; # CYRILLIC CAPITAL LETTER DZHE
+0410; C; 0430; # CYRILLIC CAPITAL LETTER A
+0411; C; 0431; # CYRILLIC CAPITAL LETTER BE
+0412; C; 0432; # CYRILLIC CAPITAL LETTER VE
+0413; C; 0433; # CYRILLIC CAPITAL LETTER GHE
+0414; C; 0434; # CYRILLIC CAPITAL LETTER DE
+0415; C; 0435; # CYRILLIC CAPITAL LETTER IE
+0416; C; 0436; # CYRILLIC CAPITAL LETTER ZHE
+0417; C; 0437; # CYRILLIC CAPITAL LETTER ZE
+0418; C; 0438; # CYRILLIC CAPITAL LETTER I
+0419; C; 0439; # CYRILLIC CAPITAL LETTER SHORT I
+041A; C; 043A; # CYRILLIC CAPITAL LETTER KA
+041B; C; 043B; # CYRILLIC CAPITAL LETTER EL
+041C; C; 043C; # CYRILLIC CAPITAL LETTER EM
+041D; C; 043D; # CYRILLIC CAPITAL LETTER EN
+041E; C; 043E; # CYRILLIC CAPITAL LETTER O
+041F; C; 043F; # CYRILLIC CAPITAL LETTER PE
+0420; C; 0440; # CYRILLIC CAPITAL LETTER ER
+0421; C; 0441; # CYRILLIC CAPITAL LETTER ES
+0422; C; 0442; # CYRILLIC CAPITAL LETTER TE
+0423; C; 0443; # CYRILLIC CAPITAL LETTER U
+0424; C; 0444; # CYRILLIC CAPITAL LETTER EF
+0425; C; 0445; # CYRILLIC CAPITAL LETTER HA
+0426; C; 0446; # CYRILLIC CAPITAL LETTER TSE
+0427; C; 0447; # CYRILLIC CAPITAL LETTER CHE
+0428; C; 0448; # CYRILLIC CAPITAL LETTER SHA
+0429; C; 0449; # CYRILLIC CAPITAL LETTER SHCHA
+042A; C; 044A; # CYRILLIC CAPITAL LETTER HARD SIGN
+042B; C; 044B; # CYRILLIC CAPITAL LETTER YERU
+042C; C; 044C; # CYRILLIC CAPITAL LETTER SOFT SIGN
+042D; C; 044D; # CYRILLIC CAPITAL LETTER E
+042E; C; 044E; # CYRILLIC CAPITAL LETTER YU
+042F; C; 044F; # CYRILLIC CAPITAL LETTER YA
+0460; C; 0461; # CYRILLIC CAPITAL LETTER OMEGA
+0462; C; 0463; # CYRILLIC CAPITAL LETTER YAT
+0464; C; 0465; # CYRILLIC CAPITAL LETTER IOTIFIED E
+0466; C; 0467; # CYRILLIC CAPITAL LETTER LITTLE YUS
+0468; C; 0469; # CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS
+046A; C; 046B; # CYRILLIC CAPITAL LETTER BIG YUS
+046C; C; 046D; # CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS
+046E; C; 046F; # CYRILLIC CAPITAL LETTER KSI
+0470; C; 0471; # CYRILLIC CAPITAL LETTER PSI
+0472; C; 0473; # CYRILLIC CAPITAL LETTER FITA
+0474; C; 0475; # CYRILLIC CAPITAL LETTER IZHITSA
+0476; C; 0477; # CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT
+0478; C; 0479; # CYRILLIC CAPITAL LETTER UK
+047A; C; 047B; # CYRILLIC CAPITAL LETTER ROUND OMEGA
+047C; C; 047D; # CYRILLIC CAPITAL LETTER OMEGA WITH TITLO
+047E; C; 047F; # CYRILLIC CAPITAL LETTER OT
+0480; C; 0481; # CYRILLIC CAPITAL LETTER KOPPA
+048A; C; 048B; # CYRILLIC CAPITAL LETTER SHORT I WITH TAIL
+048C; C; 048D; # CYRILLIC CAPITAL LETTER SEMISOFT SIGN
+048E; C; 048F; # CYRILLIC CAPITAL LETTER ER WITH TICK
+0490; C; 0491; # CYRILLIC CAPITAL LETTER GHE WITH UPTURN
+0492; C; 0493; # CYRILLIC CAPITAL LETTER GHE WITH STROKE
+0494; C; 0495; # CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK
+0496; C; 0497; # CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER
+0498; C; 0499; # CYRILLIC CAPITAL LETTER ZE WITH DESCENDER
+049A; C; 049B; # CYRILLIC CAPITAL LETTER KA WITH DESCENDER
+049C; C; 049D; # CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE
+049E; C; 049F; # CYRILLIC CAPITAL LETTER KA WITH STROKE
+04A0; C; 04A1; # CYRILLIC CAPITAL LETTER BASHKIR KA
+04A2; C; 04A3; # CYRILLIC CAPITAL LETTER EN WITH DESCENDER
+04A4; C; 04A5; # CYRILLIC CAPITAL LIGATURE EN GHE
+04A6; C; 04A7; # CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK
+04A8; C; 04A9; # CYRILLIC CAPITAL LETTER ABKHASIAN HA
+04AA; C; 04AB; # CYRILLIC CAPITAL LETTER ES WITH DESCENDER
+04AC; C; 04AD; # CYRILLIC CAPITAL LETTER TE WITH DESCENDER
+04AE; C; 04AF; # CYRILLIC CAPITAL LETTER STRAIGHT U
+04B0; C; 04B1; # CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE
+04B2; C; 04B3; # CYRILLIC CAPITAL LETTER HA WITH DESCENDER
+04B4; C; 04B5; # CYRILLIC CAPITAL LIGATURE TE TSE
+04B6; C; 04B7; # CYRILLIC CAPITAL LETTER CHE WITH DESCENDER
+04B8; C; 04B9; # CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE
+04BA; C; 04BB; # CYRILLIC CAPITAL LETTER SHHA
+04BC; C; 04BD; # CYRILLIC CAPITAL LETTER ABKHASIAN CHE
+04BE; C; 04BF; # CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER
+04C0; C; 04CF; # CYRILLIC LETTER PALOCHKA
+04C1; C; 04C2; # CYRILLIC CAPITAL LETTER ZHE WITH BREVE
+04C3; C; 04C4; # CYRILLIC CAPITAL LETTER KA WITH HOOK
+04C5; C; 04C6; # CYRILLIC CAPITAL LETTER EL WITH TAIL
+04C7; C; 04C8; # CYRILLIC CAPITAL LETTER EN WITH HOOK
+04C9; C; 04CA; # CYRILLIC CAPITAL LETTER EN WITH TAIL
+04CB; C; 04CC; # CYRILLIC CAPITAL LETTER KHAKASSIAN CHE
+04CD; C; 04CE; # CYRILLIC CAPITAL LETTER EM WITH TAIL
+04D0; C; 04D1; # CYRILLIC CAPITAL LETTER A WITH BREVE
+04D2; C; 04D3; # CYRILLIC CAPITAL LETTER A WITH DIAERESIS
+04D4; C; 04D5; # CYRILLIC CAPITAL LIGATURE A IE
+04D6; C; 04D7; # CYRILLIC CAPITAL LETTER IE WITH BREVE
+04D8; C; 04D9; # CYRILLIC CAPITAL LETTER SCHWA
+04DA; C; 04DB; # CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS
+04DC; C; 04DD; # CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS
+04DE; C; 04DF; # CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS
+04E0; C; 04E1; # CYRILLIC CAPITAL LETTER ABKHASIAN DZE
+04E2; C; 04E3; # CYRILLIC CAPITAL LETTER I WITH MACRON
+04E4; C; 04E5; # CYRILLIC CAPITAL LETTER I WITH DIAERESIS
+04E6; C; 04E7; # CYRILLIC CAPITAL LETTER O WITH DIAERESIS
+04E8; C; 04E9; # CYRILLIC CAPITAL LETTER BARRED O
+04EA; C; 04EB; # CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS
+04EC; C; 04ED; # CYRILLIC CAPITAL LETTER E WITH DIAERESIS
+04EE; C; 04EF; # CYRILLIC CAPITAL LETTER U WITH MACRON
+04F0; C; 04F1; # CYRILLIC CAPITAL LETTER U WITH DIAERESIS
+04F2; C; 04F3; # CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE
+04F4; C; 04F5; # CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS
+04F6; C; 04F7; # CYRILLIC CAPITAL LETTER GHE WITH DESCENDER
+04F8; C; 04F9; # CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS
+04FA; C; 04FB; # CYRILLIC CAPITAL LETTER GHE WITH STROKE AND HOOK
+04FC; C; 04FD; # CYRILLIC CAPITAL LETTER HA WITH HOOK
+04FE; C; 04FF; # CYRILLIC CAPITAL LETTER HA WITH STROKE
+0500; C; 0501; # CYRILLIC CAPITAL LETTER KOMI DE
+0502; C; 0503; # CYRILLIC CAPITAL LETTER KOMI DJE
+0504; C; 0505; # CYRILLIC CAPITAL LETTER KOMI ZJE
+0506; C; 0507; # CYRILLIC CAPITAL LETTER KOMI DZJE
+0508; C; 0509; # CYRILLIC CAPITAL LETTER KOMI LJE
+050A; C; 050B; # CYRILLIC CAPITAL LETTER KOMI NJE
+050C; C; 050D; # CYRILLIC CAPITAL LETTER KOMI SJE
+050E; C; 050F; # CYRILLIC CAPITAL LETTER KOMI TJE
+0510; C; 0511; # CYRILLIC CAPITAL LETTER REVERSED ZE
+0512; C; 0513; # CYRILLIC CAPITAL LETTER EL WITH HOOK
+0514; C; 0515; # CYRILLIC CAPITAL LETTER LHA
+0516; C; 0517; # CYRILLIC CAPITAL LETTER RHA
+0518; C; 0519; # CYRILLIC CAPITAL LETTER YAE
+051A; C; 051B; # CYRILLIC CAPITAL LETTER QA
+051C; C; 051D; # CYRILLIC CAPITAL LETTER WE
+051E; C; 051F; # CYRILLIC CAPITAL LETTER ALEUT KA
+0520; C; 0521; # CYRILLIC CAPITAL LETTER EL WITH MIDDLE HOOK
+0522; C; 0523; # CYRILLIC CAPITAL LETTER EN WITH MIDDLE HOOK
+0524; C; 0525; # CYRILLIC CAPITAL LETTER PE WITH DESCENDER
+0526; C; 0527; # CYRILLIC CAPITAL LETTER SHHA WITH DESCENDER
+0528; C; 0529; # CYRILLIC CAPITAL LETTER EN WITH LEFT HOOK
+052A; C; 052B; # CYRILLIC CAPITAL LETTER DZZHE
+052C; C; 052D; # CYRILLIC CAPITAL LETTER DCHE
+052E; C; 052F; # CYRILLIC CAPITAL LETTER EL WITH DESCENDER
+0531; C; 0561; # ARMENIAN CAPITAL LETTER AYB
+0532; C; 0562; # ARMENIAN CAPITAL LETTER BEN
+0533; C; 0563; # ARMENIAN CAPITAL LETTER GIM
+0534; C; 0564; # ARMENIAN CAPITAL LETTER DA
+0535; C; 0565; # ARMENIAN CAPITAL LETTER ECH
+0536; C; 0566; # ARMENIAN CAPITAL LETTER ZA
+0537; C; 0567; # ARMENIAN CAPITAL LETTER EH
+0538; C; 0568; # ARMENIAN CAPITAL LETTER ET
+0539; C; 0569; # ARMENIAN CAPITAL LETTER TO
+053A; C; 056A; # ARMENIAN CAPITAL LETTER ZHE
+053B; C; 056B; # ARMENIAN CAPITAL LETTER INI
+053C; C; 056C; # ARMENIAN CAPITAL LETTER LIWN
+053D; C; 056D; # ARMENIAN CAPITAL LETTER XEH
+053E; C; 056E; # ARMENIAN CAPITAL LETTER CA
+053F; C; 056F; # ARMENIAN CAPITAL LETTER KEN
+0540; C; 0570; # ARMENIAN CAPITAL LETTER HO
+0541; C; 0571; # ARMENIAN CAPITAL LETTER JA
+0542; C; 0572; # ARMENIAN CAPITAL LETTER GHAD
+0543; C; 0573; # ARMENIAN CAPITAL LETTER CHEH
+0544; C; 0574; # ARMENIAN CAPITAL LETTER MEN
+0545; C; 0575; # ARMENIAN CAPITAL LETTER YI
+0546; C; 0576; # ARMENIAN CAPITAL LETTER NOW
+0547; C; 0577; # ARMENIAN CAPITAL LETTER SHA
+0548; C; 0578; # ARMENIAN CAPITAL LETTER VO
+0549; C; 0579; # ARMENIAN CAPITAL LETTER CHA
+054A; C; 057A; # ARMENIAN CAPITAL LETTER PEH
+054B; C; 057B; # ARMENIAN CAPITAL LETTER JHEH
+054C; C; 057C; # ARMENIAN CAPITAL LETTER RA
+054D; C; 057D; # ARMENIAN CAPITAL LETTER SEH
+054E; C; 057E; # ARMENIAN CAPITAL LETTER VEW
+054F; C; 057F; # ARMENIAN CAPITAL LETTER TIWN
+0550; C; 0580; # ARMENIAN CAPITAL LETTER REH
+0551; C; 0581; # ARMENIAN CAPITAL LETTER CO
+0552; C; 0582; # ARMENIAN CAPITAL LETTER YIWN
+0553; C; 0583; # ARMENIAN CAPITAL LETTER PIWR
+0554; C; 0584; # ARMENIAN CAPITAL LETTER KEH
+0555; C; 0585; # ARMENIAN CAPITAL LETTER OH
+0556; C; 0586; # ARMENIAN CAPITAL LETTER FEH
+0587; F; 0565 0582; # ARMENIAN SMALL LIGATURE ECH YIWN
+10A0; C; 2D00; # GEORGIAN CAPITAL LETTER AN
+10A1; C; 2D01; # GEORGIAN CAPITAL LETTER BAN
+10A2; C; 2D02; # GEORGIAN CAPITAL LETTER GAN
+10A3; C; 2D03; # GEORGIAN CAPITAL LETTER DON
+10A4; C; 2D04; # GEORGIAN CAPITAL LETTER EN
+10A5; C; 2D05; # GEORGIAN CAPITAL LETTER VIN
+10A6; C; 2D06; # GEORGIAN CAPITAL LETTER ZEN
+10A7; C; 2D07; # GEORGIAN CAPITAL LETTER TAN
+10A8; C; 2D08; # GEORGIAN CAPITAL LETTER IN
+10A9; C; 2D09; # GEORGIAN CAPITAL LETTER KAN
+10AA; C; 2D0A; # GEORGIAN CAPITAL LETTER LAS
+10AB; C; 2D0B; # GEORGIAN CAPITAL LETTER MAN
+10AC; C; 2D0C; # GEORGIAN CAPITAL LETTER NAR
+10AD; C; 2D0D; # GEORGIAN CAPITAL LETTER ON
+10AE; C; 2D0E; # GEORGIAN CAPITAL LETTER PAR
+10AF; C; 2D0F; # GEORGIAN CAPITAL LETTER ZHAR
+10B0; C; 2D10; # GEORGIAN CAPITAL LETTER RAE
+10B1; C; 2D11; # GEORGIAN CAPITAL LETTER SAN
+10B2; C; 2D12; # GEORGIAN CAPITAL LETTER TAR
+10B3; C; 2D13; # GEORGIAN CAPITAL LETTER UN
+10B4; C; 2D14; # GEORGIAN CAPITAL LETTER PHAR
+10B5; C; 2D15; # GEORGIAN CAPITAL LETTER KHAR
+10B6; C; 2D16; # GEORGIAN CAPITAL LETTER GHAN
+10B7; C; 2D17; # GEORGIAN CAPITAL LETTER QAR
+10B8; C; 2D18; # GEORGIAN CAPITAL LETTER SHIN
+10B9; C; 2D19; # GEORGIAN CAPITAL LETTER CHIN
+10BA; C; 2D1A; # GEORGIAN CAPITAL LETTER CAN
+10BB; C; 2D1B; # GEORGIAN CAPITAL LETTER JIL
+10BC; C; 2D1C; # GEORGIAN CAPITAL LETTER CIL
+10BD; C; 2D1D; # GEORGIAN CAPITAL LETTER CHAR
+10BE; C; 2D1E; # GEORGIAN CAPITAL LETTER XAN
+10BF; C; 2D1F; # GEORGIAN CAPITAL LETTER JHAN
+10C0; C; 2D20; # GEORGIAN CAPITAL LETTER HAE
+10C1; C; 2D21; # GEORGIAN CAPITAL LETTER HE
+10C2; C; 2D22; # GEORGIAN CAPITAL LETTER HIE
+10C3; C; 2D23; # GEORGIAN CAPITAL LETTER WE
+10C4; C; 2D24; # GEORGIAN CAPITAL LETTER HAR
+10C5; C; 2D25; # GEORGIAN CAPITAL LETTER HOE
+10C7; C; 2D27; # GEORGIAN CAPITAL LETTER YN
+10CD; C; 2D2D; # GEORGIAN CAPITAL LETTER AEN
+13F8; C; 13F0; # CHEROKEE SMALL LETTER YE
+13F9; C; 13F1; # CHEROKEE SMALL LETTER YI
+13FA; C; 13F2; # CHEROKEE SMALL LETTER YO
+13FB; C; 13F3; # CHEROKEE SMALL LETTER YU
+13FC; C; 13F4; # CHEROKEE SMALL LETTER YV
+13FD; C; 13F5; # CHEROKEE SMALL LETTER MV
+1C80; C; 0432; # CYRILLIC SMALL LETTER ROUNDED VE
+1C81; C; 0434; # CYRILLIC SMALL LETTER LONG-LEGGED DE
+1C82; C; 043E; # CYRILLIC SMALL LETTER NARROW O
+1C83; C; 0441; # CYRILLIC SMALL LETTER WIDE ES
+1C84; C; 0442; # CYRILLIC SMALL LETTER TALL TE
+1C85; C; 0442; # CYRILLIC SMALL LETTER THREE-LEGGED TE
+1C86; C; 044A; # CYRILLIC SMALL LETTER TALL HARD SIGN
+1C87; C; 0463; # CYRILLIC SMALL LETTER TALL YAT
+1C88; C; A64B; # CYRILLIC SMALL LETTER UNBLENDED UK
+1C89; C; 1C8A; # CYRILLIC CAPITAL LETTER TJE
+1C90; C; 10D0; # GEORGIAN MTAVRULI CAPITAL LETTER AN
+1C91; C; 10D1; # GEORGIAN MTAVRULI CAPITAL LETTER BAN
+1C92; C; 10D2; # GEORGIAN MTAVRULI CAPITAL LETTER GAN
+1C93; C; 10D3; # GEORGIAN MTAVRULI CAPITAL LETTER DON
+1C94; C; 10D4; # GEORGIAN MTAVRULI CAPITAL LETTER EN
+1C95; C; 10D5; # GEORGIAN MTAVRULI CAPITAL LETTER VIN
+1C96; C; 10D6; # GEORGIAN MTAVRULI CAPITAL LETTER ZEN
+1C97; C; 10D7; # GEORGIAN MTAVRULI CAPITAL LETTER TAN
+1C98; C; 10D8; # GEORGIAN MTAVRULI CAPITAL LETTER IN
+1C99; C; 10D9; # GEORGIAN MTAVRULI CAPITAL LETTER KAN
+1C9A; C; 10DA; # GEORGIAN MTAVRULI CAPITAL LETTER LAS
+1C9B; C; 10DB; # GEORGIAN MTAVRULI CAPITAL LETTER MAN
+1C9C; C; 10DC; # GEORGIAN MTAVRULI CAPITAL LETTER NAR
+1C9D; C; 10DD; # GEORGIAN MTAVRULI CAPITAL LETTER ON
+1C9E; C; 10DE; # GEORGIAN MTAVRULI CAPITAL LETTER PAR
+1C9F; C; 10DF; # GEORGIAN MTAVRULI CAPITAL LETTER ZHAR
+1CA0; C; 10E0; # GEORGIAN MTAVRULI CAPITAL LETTER RAE
+1CA1; C; 10E1; # GEORGIAN MTAVRULI CAPITAL LETTER SAN
+1CA2; C; 10E2; # GEORGIAN MTAVRULI CAPITAL LETTER TAR
+1CA3; C; 10E3; # GEORGIAN MTAVRULI CAPITAL LETTER UN
+1CA4; C; 10E4; # GEORGIAN MTAVRULI CAPITAL LETTER PHAR
+1CA5; C; 10E5; # GEORGIAN MTAVRULI CAPITAL LETTER KHAR
+1CA6; C; 10E6; # GEORGIAN MTAVRULI CAPITAL LETTER GHAN
+1CA7; C; 10E7; # GEORGIAN MTAVRULI CAPITAL LETTER QAR
+1CA8; C; 10E8; # GEORGIAN MTAVRULI CAPITAL LETTER SHIN
+1CA9; C; 10E9; # GEORGIAN MTAVRULI CAPITAL LETTER CHIN
+1CAA; C; 10EA; # GEORGIAN MTAVRULI CAPITAL LETTER CAN
+1CAB; C; 10EB; # GEORGIAN MTAVRULI CAPITAL LETTER JIL
+1CAC; C; 10EC; # GEORGIAN MTAVRULI CAPITAL LETTER CIL
+1CAD; C; 10ED; # GEORGIAN MTAVRULI CAPITAL LETTER CHAR
+1CAE; C; 10EE; # GEORGIAN MTAVRULI CAPITAL LETTER XAN
+1CAF; C; 10EF; # GEORGIAN MTAVRULI CAPITAL LETTER JHAN
+1CB0; C; 10F0; # GEORGIAN MTAVRULI CAPITAL LETTER HAE
+1CB1; C; 10F1; # GEORGIAN MTAVRULI CAPITAL LETTER HE
+1CB2; C; 10F2; # GEORGIAN MTAVRULI CAPITAL LETTER HIE
+1CB3; C; 10F3; # GEORGIAN MTAVRULI CAPITAL LETTER WE
+1CB4; C; 10F4; # GEORGIAN MTAVRULI CAPITAL LETTER HAR
+1CB5; C; 10F5; # GEORGIAN MTAVRULI CAPITAL LETTER HOE
+1CB6; C; 10F6; # GEORGIAN MTAVRULI CAPITAL LETTER FI
+1CB7; C; 10F7; # GEORGIAN MTAVRULI CAPITAL LETTER YN
+1CB8; C; 10F8; # GEORGIAN MTAVRULI CAPITAL LETTER ELIFI
+1CB9; C; 10F9; # GEORGIAN MTAVRULI CAPITAL LETTER TURNED GAN
+1CBA; C; 10FA; # GEORGIAN MTAVRULI CAPITAL LETTER AIN
+1CBD; C; 10FD; # GEORGIAN MTAVRULI CAPITAL LETTER AEN
+1CBE; C; 10FE; # GEORGIAN MTAVRULI CAPITAL LETTER HARD SIGN
+1CBF; C; 10FF; # GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN
+1E00; C; 1E01; # LATIN CAPITAL LETTER A WITH RING BELOW
+1E02; C; 1E03; # LATIN CAPITAL LETTER B WITH DOT ABOVE
+1E04; C; 1E05; # LATIN CAPITAL LETTER B WITH DOT BELOW
+1E06; C; 1E07; # LATIN CAPITAL LETTER B WITH LINE BELOW
+1E08; C; 1E09; # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE
+1E0A; C; 1E0B; # LATIN CAPITAL LETTER D WITH DOT ABOVE
+1E0C; C; 1E0D; # LATIN CAPITAL LETTER D WITH DOT BELOW
+1E0E; C; 1E0F; # LATIN CAPITAL LETTER D WITH LINE BELOW
+1E10; C; 1E11; # LATIN CAPITAL LETTER D WITH CEDILLA
+1E12; C; 1E13; # LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW
+1E14; C; 1E15; # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE
+1E16; C; 1E17; # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE
+1E18; C; 1E19; # LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW
+1E1A; C; 1E1B; # LATIN CAPITAL LETTER E WITH TILDE BELOW
+1E1C; C; 1E1D; # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE
+1E1E; C; 1E1F; # LATIN CAPITAL LETTER F WITH DOT ABOVE
+1E20; C; 1E21; # LATIN CAPITAL LETTER G WITH MACRON
+1E22; C; 1E23; # LATIN CAPITAL LETTER H WITH DOT ABOVE
+1E24; C; 1E25; # LATIN CAPITAL LETTER H WITH DOT BELOW
+1E26; C; 1E27; # LATIN CAPITAL LETTER H WITH DIAERESIS
+1E28; C; 1E29; # LATIN CAPITAL LETTER H WITH CEDILLA
+1E2A; C; 1E2B; # LATIN CAPITAL LETTER H WITH BREVE BELOW
+1E2C; C; 1E2D; # LATIN CAPITAL LETTER I WITH TILDE BELOW
+1E2E; C; 1E2F; # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE
+1E30; C; 1E31; # LATIN CAPITAL LETTER K WITH ACUTE
+1E32; C; 1E33; # LATIN CAPITAL LETTER K WITH DOT BELOW
+1E34; C; 1E35; # LATIN CAPITAL LETTER K WITH LINE BELOW
+1E36; C; 1E37; # LATIN CAPITAL LETTER L WITH DOT BELOW
+1E38; C; 1E39; # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON
+1E3A; C; 1E3B; # LATIN CAPITAL LETTER L WITH LINE BELOW
+1E3C; C; 1E3D; # LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW
+1E3E; C; 1E3F; # LATIN CAPITAL LETTER M WITH ACUTE
+1E40; C; 1E41; # LATIN CAPITAL LETTER M WITH DOT ABOVE
+1E42; C; 1E43; # LATIN CAPITAL LETTER M WITH DOT BELOW
+1E44; C; 1E45; # LATIN CAPITAL LETTER N WITH DOT ABOVE
+1E46; C; 1E47; # LATIN CAPITAL LETTER N WITH DOT BELOW
+1E48; C; 1E49; # LATIN CAPITAL LETTER N WITH LINE BELOW
+1E4A; C; 1E4B; # LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW
+1E4C; C; 1E4D; # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE
+1E4E; C; 1E4F; # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS
+1E50; C; 1E51; # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE
+1E52; C; 1E53; # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE
+1E54; C; 1E55; # LATIN CAPITAL LETTER P WITH ACUTE
+1E56; C; 1E57; # LATIN CAPITAL LETTER P WITH DOT ABOVE
+1E58; C; 1E59; # LATIN CAPITAL LETTER R WITH DOT ABOVE
+1E5A; C; 1E5B; # LATIN CAPITAL LETTER R WITH DOT BELOW
+1E5C; C; 1E5D; # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON
+1E5E; C; 1E5F; # LATIN CAPITAL LETTER R WITH LINE BELOW
+1E60; C; 1E61; # LATIN CAPITAL LETTER S WITH DOT ABOVE
+1E62; C; 1E63; # LATIN CAPITAL LETTER S WITH DOT BELOW
+1E64; C; 1E65; # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE
+1E66; C; 1E67; # LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE
+1E68; C; 1E69; # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE
+1E6A; C; 1E6B; # LATIN CAPITAL LETTER T WITH DOT ABOVE
+1E6C; C; 1E6D; # LATIN CAPITAL LETTER T WITH DOT BELOW
+1E6E; C; 1E6F; # LATIN CAPITAL LETTER T WITH LINE BELOW
+1E70; C; 1E71; # LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW
+1E72; C; 1E73; # LATIN CAPITAL LETTER U WITH DIAERESIS BELOW
+1E74; C; 1E75; # LATIN CAPITAL LETTER U WITH TILDE BELOW
+1E76; C; 1E77; # LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW
+1E78; C; 1E79; # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE
+1E7A; C; 1E7B; # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS
+1E7C; C; 1E7D; # LATIN CAPITAL LETTER V WITH TILDE
+1E7E; C; 1E7F; # LATIN CAPITAL LETTER V WITH DOT BELOW
+1E80; C; 1E81; # LATIN CAPITAL LETTER W WITH GRAVE
+1E82; C; 1E83; # LATIN CAPITAL LETTER W WITH ACUTE
+1E84; C; 1E85; # LATIN CAPITAL LETTER W WITH DIAERESIS
+1E86; C; 1E87; # LATIN CAPITAL LETTER W WITH DOT ABOVE
+1E88; C; 1E89; # LATIN CAPITAL LETTER W WITH DOT BELOW
+1E8A; C; 1E8B; # LATIN CAPITAL LETTER X WITH DOT ABOVE
+1E8C; C; 1E8D; # LATIN CAPITAL LETTER X WITH DIAERESIS
+1E8E; C; 1E8F; # LATIN CAPITAL LETTER Y WITH DOT ABOVE
+1E90; C; 1E91; # LATIN CAPITAL LETTER Z WITH CIRCUMFLEX
+1E92; C; 1E93; # LATIN CAPITAL LETTER Z WITH DOT BELOW
+1E94; C; 1E95; # LATIN CAPITAL LETTER Z WITH LINE BELOW
+1E96; F; 0068 0331; # LATIN SMALL LETTER H WITH LINE BELOW
+1E97; F; 0074 0308; # LATIN SMALL LETTER T WITH DIAERESIS
+1E98; F; 0077 030A; # LATIN SMALL LETTER W WITH RING ABOVE
+1E99; F; 0079 030A; # LATIN SMALL LETTER Y WITH RING ABOVE
+1E9A; F; 0061 02BE; # LATIN SMALL LETTER A WITH RIGHT HALF RING
+1E9B; C; 1E61; # LATIN SMALL LETTER LONG S WITH DOT ABOVE
+1E9E; F; 0073 0073; # LATIN CAPITAL LETTER SHARP S
+1E9E; S; 00DF; # LATIN CAPITAL LETTER SHARP S
+1EA0; C; 1EA1; # LATIN CAPITAL LETTER A WITH DOT BELOW
+1EA2; C; 1EA3; # LATIN CAPITAL LETTER A WITH HOOK ABOVE
+1EA4; C; 1EA5; # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE
+1EA6; C; 1EA7; # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE
+1EA8; C; 1EA9; # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE
+1EAA; C; 1EAB; # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE
+1EAC; C; 1EAD; # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW
+1EAE; C; 1EAF; # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE
+1EB0; C; 1EB1; # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE
+1EB2; C; 1EB3; # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE
+1EB4; C; 1EB5; # LATIN CAPITAL LETTER A WITH BREVE AND TILDE
+1EB6; C; 1EB7; # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW
+1EB8; C; 1EB9; # LATIN CAPITAL LETTER E WITH DOT BELOW
+1EBA; C; 1EBB; # LATIN CAPITAL LETTER E WITH HOOK ABOVE
+1EBC; C; 1EBD; # LATIN CAPITAL LETTER E WITH TILDE
+1EBE; C; 1EBF; # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE
+1EC0; C; 1EC1; # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE
+1EC2; C; 1EC3; # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE
+1EC4; C; 1EC5; # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE
+1EC6; C; 1EC7; # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW
+1EC8; C; 1EC9; # LATIN CAPITAL LETTER I WITH HOOK ABOVE
+1ECA; C; 1ECB; # LATIN CAPITAL LETTER I WITH DOT BELOW
+1ECC; C; 1ECD; # LATIN CAPITAL LETTER O WITH DOT BELOW
+1ECE; C; 1ECF; # LATIN CAPITAL LETTER O WITH HOOK ABOVE
+1ED0; C; 1ED1; # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE
+1ED2; C; 1ED3; # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE
+1ED4; C; 1ED5; # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE
+1ED6; C; 1ED7; # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE
+1ED8; C; 1ED9; # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW
+1EDA; C; 1EDB; # LATIN CAPITAL LETTER O WITH HORN AND ACUTE
+1EDC; C; 1EDD; # LATIN CAPITAL LETTER O WITH HORN AND GRAVE
+1EDE; C; 1EDF; # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE
+1EE0; C; 1EE1; # LATIN CAPITAL LETTER O WITH HORN AND TILDE
+1EE2; C; 1EE3; # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW
+1EE4; C; 1EE5; # LATIN CAPITAL LETTER U WITH DOT BELOW
+1EE6; C; 1EE7; # LATIN CAPITAL LETTER U WITH HOOK ABOVE
+1EE8; C; 1EE9; # LATIN CAPITAL LETTER U WITH HORN AND ACUTE
+1EEA; C; 1EEB; # LATIN CAPITAL LETTER U WITH HORN AND GRAVE
+1EEC; C; 1EED; # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE
+1EEE; C; 1EEF; # LATIN CAPITAL LETTER U WITH HORN AND TILDE
+1EF0; C; 1EF1; # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW
+1EF2; C; 1EF3; # LATIN CAPITAL LETTER Y WITH GRAVE
+1EF4; C; 1EF5; # LATIN CAPITAL LETTER Y WITH DOT BELOW
+1EF6; C; 1EF7; # LATIN CAPITAL LETTER Y WITH HOOK ABOVE
+1EF8; C; 1EF9; # LATIN CAPITAL LETTER Y WITH TILDE
+1EFA; C; 1EFB; # LATIN CAPITAL LETTER MIDDLE-WELSH LL
+1EFC; C; 1EFD; # LATIN CAPITAL LETTER MIDDLE-WELSH V
+1EFE; C; 1EFF; # LATIN CAPITAL LETTER Y WITH LOOP
+1F08; C; 1F00; # GREEK CAPITAL LETTER ALPHA WITH PSILI
+1F09; C; 1F01; # GREEK CAPITAL LETTER ALPHA WITH DASIA
+1F0A; C; 1F02; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA
+1F0B; C; 1F03; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA
+1F0C; C; 1F04; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA
+1F0D; C; 1F05; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA
+1F0E; C; 1F06; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI
+1F0F; C; 1F07; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI
+1F18; C; 1F10; # GREEK CAPITAL LETTER EPSILON WITH PSILI
+1F19; C; 1F11; # GREEK CAPITAL LETTER EPSILON WITH DASIA
+1F1A; C; 1F12; # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA
+1F1B; C; 1F13; # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA
+1F1C; C; 1F14; # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA
+1F1D; C; 1F15; # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
+1F28; C; 1F20; # GREEK CAPITAL LETTER ETA WITH PSILI
+1F29; C; 1F21; # GREEK CAPITAL LETTER ETA WITH DASIA
+1F2A; C; 1F22; # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA
+1F2B; C; 1F23; # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA
+1F2C; C; 1F24; # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA
+1F2D; C; 1F25; # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA
+1F2E; C; 1F26; # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI
+1F2F; C; 1F27; # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI
+1F38; C; 1F30; # GREEK CAPITAL LETTER IOTA WITH PSILI
+1F39; C; 1F31; # GREEK CAPITAL LETTER IOTA WITH DASIA
+1F3A; C; 1F32; # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA
+1F3B; C; 1F33; # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA
+1F3C; C; 1F34; # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA
+1F3D; C; 1F35; # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA
+1F3E; C; 1F36; # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI
+1F3F; C; 1F37; # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI
+1F48; C; 1F40; # GREEK CAPITAL LETTER OMICRON WITH PSILI
+1F49; C; 1F41; # GREEK CAPITAL LETTER OMICRON WITH DASIA
+1F4A; C; 1F42; # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA
+1F4B; C; 1F43; # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA
+1F4C; C; 1F44; # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA
+1F4D; C; 1F45; # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA
+1F50; F; 03C5 0313; # GREEK SMALL LETTER UPSILON WITH PSILI
+1F52; F; 03C5 0313 0300; # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA
+1F54; F; 03C5 0313 0301; # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA
+1F56; F; 03C5 0313 0342; # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI
+1F59; C; 1F51; # GREEK CAPITAL LETTER UPSILON WITH DASIA
+1F5B; C; 1F53; # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA
+1F5D; C; 1F55; # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA
+1F5F; C; 1F57; # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI
+1F68; C; 1F60; # GREEK CAPITAL LETTER OMEGA WITH PSILI
+1F69; C; 1F61; # GREEK CAPITAL LETTER OMEGA WITH DASIA
+1F6A; C; 1F62; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA
+1F6B; C; 1F63; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA
+1F6C; C; 1F64; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA
+1F6D; C; 1F65; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA
+1F6E; C; 1F66; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI
+1F6F; C; 1F67; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI
+1F80; F; 1F00 03B9; # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI
+1F81; F; 1F01 03B9; # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI
+1F82; F; 1F02 03B9; # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1F83; F; 1F03 03B9; # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1F84; F; 1F04 03B9; # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1F85; F; 1F05 03B9; # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1F86; F; 1F06 03B9; # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1F87; F; 1F07 03B9; # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1F88; F; 1F00 03B9; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI
+1F88; S; 1F80; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI
+1F89; F; 1F01 03B9; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI
+1F89; S; 1F81; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI
+1F8A; F; 1F02 03B9; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F8A; S; 1F82; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F8B; F; 1F03 03B9; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F8B; S; 1F83; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F8C; F; 1F04 03B9; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F8C; S; 1F84; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F8D; F; 1F05 03B9; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F8D; S; 1F85; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F8E; F; 1F06 03B9; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F8E; S; 1F86; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F8F; F; 1F07 03B9; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1F8F; S; 1F87; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1F90; F; 1F20 03B9; # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI
+1F91; F; 1F21 03B9; # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI
+1F92; F; 1F22 03B9; # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1F93; F; 1F23 03B9; # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1F94; F; 1F24 03B9; # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1F95; F; 1F25 03B9; # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1F96; F; 1F26 03B9; # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1F97; F; 1F27 03B9; # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1F98; F; 1F20 03B9; # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI
+1F98; S; 1F90; # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI
+1F99; F; 1F21 03B9; # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI
+1F99; S; 1F91; # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI
+1F9A; F; 1F22 03B9; # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F9A; S; 1F92; # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F9B; F; 1F23 03B9; # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F9B; S; 1F93; # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F9C; F; 1F24 03B9; # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F9C; S; 1F94; # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F9D; F; 1F25 03B9; # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F9D; S; 1F95; # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F9E; F; 1F26 03B9; # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F9E; S; 1F96; # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F9F; F; 1F27 03B9; # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1F9F; S; 1F97; # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FA0; F; 1F60 03B9; # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI
+1FA1; F; 1F61 03B9; # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI
+1FA2; F; 1F62 03B9; # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1FA3; F; 1F63 03B9; # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1FA4; F; 1F64 03B9; # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1FA5; F; 1F65 03B9; # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1FA6; F; 1F66 03B9; # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1FA7; F; 1F67 03B9; # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1FA8; F; 1F60 03B9; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI
+1FA8; S; 1FA0; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI
+1FA9; F; 1F61 03B9; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI
+1FA9; S; 1FA1; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI
+1FAA; F; 1F62 03B9; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1FAA; S; 1FA2; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1FAB; F; 1F63 03B9; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1FAB; S; 1FA3; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1FAC; F; 1F64 03B9; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1FAC; S; 1FA4; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1FAD; F; 1F65 03B9; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1FAD; S; 1FA5; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1FAE; F; 1F66 03B9; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1FAE; S; 1FA6; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1FAF; F; 1F67 03B9; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FAF; S; 1FA7; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FB2; F; 1F70 03B9; # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI
+1FB3; F; 03B1 03B9; # GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI
+1FB4; F; 03AC 03B9; # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
+1FB6; F; 03B1 0342; # GREEK SMALL LETTER ALPHA WITH PERISPOMENI
+1FB7; F; 03B1 0342 03B9; # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FB8; C; 1FB0; # GREEK CAPITAL LETTER ALPHA WITH VRACHY
+1FB9; C; 1FB1; # GREEK CAPITAL LETTER ALPHA WITH MACRON
+1FBA; C; 1F70; # GREEK CAPITAL LETTER ALPHA WITH VARIA
+1FBB; C; 1F71; # GREEK CAPITAL LETTER ALPHA WITH OXIA
+1FBC; F; 03B1 03B9; # GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
+1FBC; S; 1FB3; # GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
+1FBE; C; 03B9; # GREEK PROSGEGRAMMENI
+1FC2; F; 1F74 03B9; # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI
+1FC3; F; 03B7 03B9; # GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI
+1FC4; F; 03AE 03B9; # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
+1FC6; F; 03B7 0342; # GREEK SMALL LETTER ETA WITH PERISPOMENI
+1FC7; F; 03B7 0342 03B9; # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FC8; C; 1F72; # GREEK CAPITAL LETTER EPSILON WITH VARIA
+1FC9; C; 1F73; # GREEK CAPITAL LETTER EPSILON WITH OXIA
+1FCA; C; 1F74; # GREEK CAPITAL LETTER ETA WITH VARIA
+1FCB; C; 1F75; # GREEK CAPITAL LETTER ETA WITH OXIA
+1FCC; F; 03B7 03B9; # GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
+1FCC; S; 1FC3; # GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
+1FD2; F; 03B9 0308 0300; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA
+1FD3; F; 03B9 0308 0301; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+1FD3; S; 0390; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+1FD6; F; 03B9 0342; # GREEK SMALL LETTER IOTA WITH PERISPOMENI
+1FD7; F; 03B9 0308 0342; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI
+1FD8; C; 1FD0; # GREEK CAPITAL LETTER IOTA WITH VRACHY
+1FD9; C; 1FD1; # GREEK CAPITAL LETTER IOTA WITH MACRON
+1FDA; C; 1F76; # GREEK CAPITAL LETTER IOTA WITH VARIA
+1FDB; C; 1F77; # GREEK CAPITAL LETTER IOTA WITH OXIA
+1FE2; F; 03C5 0308 0300; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA
+1FE3; F; 03C5 0308 0301; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
+1FE3; S; 03B0; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
+1FE4; F; 03C1 0313; # GREEK SMALL LETTER RHO WITH PSILI
+1FE6; F; 03C5 0342; # GREEK SMALL LETTER UPSILON WITH PERISPOMENI
+1FE7; F; 03C5 0308 0342; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI
+1FE8; C; 1FE0; # GREEK CAPITAL LETTER UPSILON WITH VRACHY
+1FE9; C; 1FE1; # GREEK CAPITAL LETTER UPSILON WITH MACRON
+1FEA; C; 1F7A; # GREEK CAPITAL LETTER UPSILON WITH VARIA
+1FEB; C; 1F7B; # GREEK CAPITAL LETTER UPSILON WITH OXIA
+1FEC; C; 1FE5; # GREEK CAPITAL LETTER RHO WITH DASIA
+1FF2; F; 1F7C 03B9; # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI
+1FF3; F; 03C9 03B9; # GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI
+1FF4; F; 03CE 03B9; # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
+1FF6; F; 03C9 0342; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI
+1FF7; F; 03C9 0342 03B9; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FF8; C; 1F78; # GREEK CAPITAL LETTER OMICRON WITH VARIA
+1FF9; C; 1F79; # GREEK CAPITAL LETTER OMICRON WITH OXIA
+1FFA; C; 1F7C; # GREEK CAPITAL LETTER OMEGA WITH VARIA
+1FFB; C; 1F7D; # GREEK CAPITAL LETTER OMEGA WITH OXIA
+1FFC; F; 03C9 03B9; # GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+1FFC; S; 1FF3; # GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+2126; C; 03C9; # OHM SIGN
+212A; C; 006B; # KELVIN SIGN
+212B; C; 00E5; # ANGSTROM SIGN
+2132; C; 214E; # TURNED CAPITAL F
+2160; C; 2170; # ROMAN NUMERAL ONE
+2161; C; 2171; # ROMAN NUMERAL TWO
+2162; C; 2172; # ROMAN NUMERAL THREE
+2163; C; 2173; # ROMAN NUMERAL FOUR
+2164; C; 2174; # ROMAN NUMERAL FIVE
+2165; C; 2175; # ROMAN NUMERAL SIX
+2166; C; 2176; # ROMAN NUMERAL SEVEN
+2167; C; 2177; # ROMAN NUMERAL EIGHT
+2168; C; 2178; # ROMAN NUMERAL NINE
+2169; C; 2179; # ROMAN NUMERAL TEN
+216A; C; 217A; # ROMAN NUMERAL ELEVEN
+216B; C; 217B; # ROMAN NUMERAL TWELVE
+216C; C; 217C; # ROMAN NUMERAL FIFTY
+216D; C; 217D; # ROMAN NUMERAL ONE HUNDRED
+216E; C; 217E; # ROMAN NUMERAL FIVE HUNDRED
+216F; C; 217F; # ROMAN NUMERAL ONE THOUSAND
+2183; C; 2184; # ROMAN NUMERAL REVERSED ONE HUNDRED
+24B6; C; 24D0; # CIRCLED LATIN CAPITAL LETTER A
+24B7; C; 24D1; # CIRCLED LATIN CAPITAL LETTER B
+24B8; C; 24D2; # CIRCLED LATIN CAPITAL LETTER C
+24B9; C; 24D3; # CIRCLED LATIN CAPITAL LETTER D
+24BA; C; 24D4; # CIRCLED LATIN CAPITAL LETTER E
+24BB; C; 24D5; # CIRCLED LATIN CAPITAL LETTER F
+24BC; C; 24D6; # CIRCLED LATIN CAPITAL LETTER G
+24BD; C; 24D7; # CIRCLED LATIN CAPITAL LETTER H
+24BE; C; 24D8; # CIRCLED LATIN CAPITAL LETTER I
+24BF; C; 24D9; # CIRCLED LATIN CAPITAL LETTER J
+24C0; C; 24DA; # CIRCLED LATIN CAPITAL LETTER K
+24C1; C; 24DB; # CIRCLED LATIN CAPITAL LETTER L
+24C2; C; 24DC; # CIRCLED LATIN CAPITAL LETTER M
+24C3; C; 24DD; # CIRCLED LATIN CAPITAL LETTER N
+24C4; C; 24DE; # CIRCLED LATIN CAPITAL LETTER O
+24C5; C; 24DF; # CIRCLED LATIN CAPITAL LETTER P
+24C6; C; 24E0; # CIRCLED LATIN CAPITAL LETTER Q
+24C7; C; 24E1; # CIRCLED LATIN CAPITAL LETTER R
+24C8; C; 24E2; # CIRCLED LATIN CAPITAL LETTER S
+24C9; C; 24E3; # CIRCLED LATIN CAPITAL LETTER T
+24CA; C; 24E4; # CIRCLED LATIN CAPITAL LETTER U
+24CB; C; 24E5; # CIRCLED LATIN CAPITAL LETTER V
+24CC; C; 24E6; # CIRCLED LATIN CAPITAL LETTER W
+24CD; C; 24E7; # CIRCLED LATIN CAPITAL LETTER X
+24CE; C; 24E8; # CIRCLED LATIN CAPITAL LETTER Y
+24CF; C; 24E9; # CIRCLED LATIN CAPITAL LETTER Z
+2C00; C; 2C30; # GLAGOLITIC CAPITAL LETTER AZU
+2C01; C; 2C31; # GLAGOLITIC CAPITAL LETTER BUKY
+2C02; C; 2C32; # GLAGOLITIC CAPITAL LETTER VEDE
+2C03; C; 2C33; # GLAGOLITIC CAPITAL LETTER GLAGOLI
+2C04; C; 2C34; # GLAGOLITIC CAPITAL LETTER DOBRO
+2C05; C; 2C35; # GLAGOLITIC CAPITAL LETTER YESTU
+2C06; C; 2C36; # GLAGOLITIC CAPITAL LETTER ZHIVETE
+2C07; C; 2C37; # GLAGOLITIC CAPITAL LETTER DZELO
+2C08; C; 2C38; # GLAGOLITIC CAPITAL LETTER ZEMLJA
+2C09; C; 2C39; # GLAGOLITIC CAPITAL LETTER IZHE
+2C0A; C; 2C3A; # GLAGOLITIC CAPITAL LETTER INITIAL IZHE
+2C0B; C; 2C3B; # GLAGOLITIC CAPITAL LETTER I
+2C0C; C; 2C3C; # GLAGOLITIC CAPITAL LETTER DJERVI
+2C0D; C; 2C3D; # GLAGOLITIC CAPITAL LETTER KAKO
+2C0E; C; 2C3E; # GLAGOLITIC CAPITAL LETTER LJUDIJE
+2C0F; C; 2C3F; # GLAGOLITIC CAPITAL LETTER MYSLITE
+2C10; C; 2C40; # GLAGOLITIC CAPITAL LETTER NASHI
+2C11; C; 2C41; # GLAGOLITIC CAPITAL LETTER ONU
+2C12; C; 2C42; # GLAGOLITIC CAPITAL LETTER POKOJI
+2C13; C; 2C43; # GLAGOLITIC CAPITAL LETTER RITSI
+2C14; C; 2C44; # GLAGOLITIC CAPITAL LETTER SLOVO
+2C15; C; 2C45; # GLAGOLITIC CAPITAL LETTER TVRIDO
+2C16; C; 2C46; # GLAGOLITIC CAPITAL LETTER UKU
+2C17; C; 2C47; # GLAGOLITIC CAPITAL LETTER FRITU
+2C18; C; 2C48; # GLAGOLITIC CAPITAL LETTER HERU
+2C19; C; 2C49; # GLAGOLITIC CAPITAL LETTER OTU
+2C1A; C; 2C4A; # GLAGOLITIC CAPITAL LETTER PE
+2C1B; C; 2C4B; # GLAGOLITIC CAPITAL LETTER SHTA
+2C1C; C; 2C4C; # GLAGOLITIC CAPITAL LETTER TSI
+2C1D; C; 2C4D; # GLAGOLITIC CAPITAL LETTER CHRIVI
+2C1E; C; 2C4E; # GLAGOLITIC CAPITAL LETTER SHA
+2C1F; C; 2C4F; # GLAGOLITIC CAPITAL LETTER YERU
+2C20; C; 2C50; # GLAGOLITIC CAPITAL LETTER YERI
+2C21; C; 2C51; # GLAGOLITIC CAPITAL LETTER YATI
+2C22; C; 2C52; # GLAGOLITIC CAPITAL LETTER SPIDERY HA
+2C23; C; 2C53; # GLAGOLITIC CAPITAL LETTER YU
+2C24; C; 2C54; # GLAGOLITIC CAPITAL LETTER SMALL YUS
+2C25; C; 2C55; # GLAGOLITIC CAPITAL LETTER SMALL YUS WITH TAIL
+2C26; C; 2C56; # GLAGOLITIC CAPITAL LETTER YO
+2C27; C; 2C57; # GLAGOLITIC CAPITAL LETTER IOTATED SMALL YUS
+2C28; C; 2C58; # GLAGOLITIC CAPITAL LETTER BIG YUS
+2C29; C; 2C59; # GLAGOLITIC CAPITAL LETTER IOTATED BIG YUS
+2C2A; C; 2C5A; # GLAGOLITIC CAPITAL LETTER FITA
+2C2B; C; 2C5B; # GLAGOLITIC CAPITAL LETTER IZHITSA
+2C2C; C; 2C5C; # GLAGOLITIC CAPITAL LETTER SHTAPIC
+2C2D; C; 2C5D; # GLAGOLITIC CAPITAL LETTER TROKUTASTI A
+2C2E; C; 2C5E; # GLAGOLITIC CAPITAL LETTER LATINATE MYSLITE
+2C2F; C; 2C5F; # GLAGOLITIC CAPITAL LETTER CAUDATE CHRIVI
+2C60; C; 2C61; # LATIN CAPITAL LETTER L WITH DOUBLE BAR
+2C62; C; 026B; # LATIN CAPITAL LETTER L WITH MIDDLE TILDE
+2C63; C; 1D7D; # LATIN CAPITAL LETTER P WITH STROKE
+2C64; C; 027D; # LATIN CAPITAL LETTER R WITH TAIL
+2C67; C; 2C68; # LATIN CAPITAL LETTER H WITH DESCENDER
+2C69; C; 2C6A; # LATIN CAPITAL LETTER K WITH DESCENDER
+2C6B; C; 2C6C; # LATIN CAPITAL LETTER Z WITH DESCENDER
+2C6D; C; 0251; # LATIN CAPITAL LETTER ALPHA
+2C6E; C; 0271; # LATIN CAPITAL LETTER M WITH HOOK
+2C6F; C; 0250; # LATIN CAPITAL LETTER TURNED A
+2C70; C; 0252; # LATIN CAPITAL LETTER TURNED ALPHA
+2C72; C; 2C73; # LATIN CAPITAL LETTER W WITH HOOK
+2C75; C; 2C76; # LATIN CAPITAL LETTER HALF H
+2C7E; C; 023F; # LATIN CAPITAL LETTER S WITH SWASH TAIL
+2C7F; C; 0240; # LATIN CAPITAL LETTER Z WITH SWASH TAIL
+2C80; C; 2C81; # COPTIC CAPITAL LETTER ALFA
+2C82; C; 2C83; # COPTIC CAPITAL LETTER VIDA
+2C84; C; 2C85; # COPTIC CAPITAL LETTER GAMMA
+2C86; C; 2C87; # COPTIC CAPITAL LETTER DALDA
+2C88; C; 2C89; # COPTIC CAPITAL LETTER EIE
+2C8A; C; 2C8B; # COPTIC CAPITAL LETTER SOU
+2C8C; C; 2C8D; # COPTIC CAPITAL LETTER ZATA
+2C8E; C; 2C8F; # COPTIC CAPITAL LETTER HATE
+2C90; C; 2C91; # COPTIC CAPITAL LETTER THETHE
+2C92; C; 2C93; # COPTIC CAPITAL LETTER IAUDA
+2C94; C; 2C95; # COPTIC CAPITAL LETTER KAPA
+2C96; C; 2C97; # COPTIC CAPITAL LETTER LAULA
+2C98; C; 2C99; # COPTIC CAPITAL LETTER MI
+2C9A; C; 2C9B; # COPTIC CAPITAL LETTER NI
+2C9C; C; 2C9D; # COPTIC CAPITAL LETTER KSI
+2C9E; C; 2C9F; # COPTIC CAPITAL LETTER O
+2CA0; C; 2CA1; # COPTIC CAPITAL LETTER PI
+2CA2; C; 2CA3; # COPTIC CAPITAL LETTER RO
+2CA4; C; 2CA5; # COPTIC CAPITAL LETTER SIMA
+2CA6; C; 2CA7; # COPTIC CAPITAL LETTER TAU
+2CA8; C; 2CA9; # COPTIC CAPITAL LETTER UA
+2CAA; C; 2CAB; # COPTIC CAPITAL LETTER FI
+2CAC; C; 2CAD; # COPTIC CAPITAL LETTER KHI
+2CAE; C; 2CAF; # COPTIC CAPITAL LETTER PSI
+2CB0; C; 2CB1; # COPTIC CAPITAL LETTER OOU
+2CB2; C; 2CB3; # COPTIC CAPITAL LETTER DIALECT-P ALEF
+2CB4; C; 2CB5; # COPTIC CAPITAL LETTER OLD COPTIC AIN
+2CB6; C; 2CB7; # COPTIC CAPITAL LETTER CRYPTOGRAMMIC EIE
+2CB8; C; 2CB9; # COPTIC CAPITAL LETTER DIALECT-P KAPA
+2CBA; C; 2CBB; # COPTIC CAPITAL LETTER DIALECT-P NI
+2CBC; C; 2CBD; # COPTIC CAPITAL LETTER CRYPTOGRAMMIC NI
+2CBE; C; 2CBF; # COPTIC CAPITAL LETTER OLD COPTIC OOU
+2CC0; C; 2CC1; # COPTIC CAPITAL LETTER SAMPI
+2CC2; C; 2CC3; # COPTIC CAPITAL LETTER CROSSED SHEI
+2CC4; C; 2CC5; # COPTIC CAPITAL LETTER OLD COPTIC SHEI
+2CC6; C; 2CC7; # COPTIC CAPITAL LETTER OLD COPTIC ESH
+2CC8; C; 2CC9; # COPTIC CAPITAL LETTER AKHMIMIC KHEI
+2CCA; C; 2CCB; # COPTIC CAPITAL LETTER DIALECT-P HORI
+2CCC; C; 2CCD; # COPTIC CAPITAL LETTER OLD COPTIC HORI
+2CCE; C; 2CCF; # COPTIC CAPITAL LETTER OLD COPTIC HA
+2CD0; C; 2CD1; # COPTIC CAPITAL LETTER L-SHAPED HA
+2CD2; C; 2CD3; # COPTIC CAPITAL LETTER OLD COPTIC HEI
+2CD4; C; 2CD5; # COPTIC CAPITAL LETTER OLD COPTIC HAT
+2CD6; C; 2CD7; # COPTIC CAPITAL LETTER OLD COPTIC GANGIA
+2CD8; C; 2CD9; # COPTIC CAPITAL LETTER OLD COPTIC DJA
+2CDA; C; 2CDB; # COPTIC CAPITAL LETTER OLD COPTIC SHIMA
+2CDC; C; 2CDD; # COPTIC CAPITAL LETTER OLD NUBIAN SHIMA
+2CDE; C; 2CDF; # COPTIC CAPITAL LETTER OLD NUBIAN NGI
+2CE0; C; 2CE1; # COPTIC CAPITAL LETTER OLD NUBIAN NYI
+2CE2; C; 2CE3; # COPTIC CAPITAL LETTER OLD NUBIAN WAU
+2CEB; C; 2CEC; # COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI
+2CED; C; 2CEE; # COPTIC CAPITAL LETTER CRYPTOGRAMMIC GANGIA
+2CF2; C; 2CF3; # COPTIC CAPITAL LETTER BOHAIRIC KHEI
+A640; C; A641; # CYRILLIC CAPITAL LETTER ZEMLYA
+A642; C; A643; # CYRILLIC CAPITAL LETTER DZELO
+A644; C; A645; # CYRILLIC CAPITAL LETTER REVERSED DZE
+A646; C; A647; # CYRILLIC CAPITAL LETTER IOTA
+A648; C; A649; # CYRILLIC CAPITAL LETTER DJERV
+A64A; C; A64B; # CYRILLIC CAPITAL LETTER MONOGRAPH UK
+A64C; C; A64D; # CYRILLIC CAPITAL LETTER BROAD OMEGA
+A64E; C; A64F; # CYRILLIC CAPITAL LETTER NEUTRAL YER
+A650; C; A651; # CYRILLIC CAPITAL LETTER YERU WITH BACK YER
+A652; C; A653; # CYRILLIC CAPITAL LETTER IOTIFIED YAT
+A654; C; A655; # CYRILLIC CAPITAL LETTER REVERSED YU
+A656; C; A657; # CYRILLIC CAPITAL LETTER IOTIFIED A
+A658; C; A659; # CYRILLIC CAPITAL LETTER CLOSED LITTLE YUS
+A65A; C; A65B; # CYRILLIC CAPITAL LETTER BLENDED YUS
+A65C; C; A65D; # CYRILLIC CAPITAL LETTER IOTIFIED CLOSED LITTLE YUS
+A65E; C; A65F; # CYRILLIC CAPITAL LETTER YN
+A660; C; A661; # CYRILLIC CAPITAL LETTER REVERSED TSE
+A662; C; A663; # CYRILLIC CAPITAL LETTER SOFT DE
+A664; C; A665; # CYRILLIC CAPITAL LETTER SOFT EL
+A666; C; A667; # CYRILLIC CAPITAL LETTER SOFT EM
+A668; C; A669; # CYRILLIC CAPITAL LETTER MONOCULAR O
+A66A; C; A66B; # CYRILLIC CAPITAL LETTER BINOCULAR O
+A66C; C; A66D; # CYRILLIC CAPITAL LETTER DOUBLE MONOCULAR O
+A680; C; A681; # CYRILLIC CAPITAL LETTER DWE
+A682; C; A683; # CYRILLIC CAPITAL LETTER DZWE
+A684; C; A685; # CYRILLIC CAPITAL LETTER ZHWE
+A686; C; A687; # CYRILLIC CAPITAL LETTER CCHE
+A688; C; A689; # CYRILLIC CAPITAL LETTER DZZE
+A68A; C; A68B; # CYRILLIC CAPITAL LETTER TE WITH MIDDLE HOOK
+A68C; C; A68D; # CYRILLIC CAPITAL LETTER TWE
+A68E; C; A68F; # CYRILLIC CAPITAL LETTER TSWE
+A690; C; A691; # CYRILLIC CAPITAL LETTER TSSE
+A692; C; A693; # CYRILLIC CAPITAL LETTER TCHE
+A694; C; A695; # CYRILLIC CAPITAL LETTER HWE
+A696; C; A697; # CYRILLIC CAPITAL LETTER SHWE
+A698; C; A699; # CYRILLIC CAPITAL LETTER DOUBLE O
+A69A; C; A69B; # CYRILLIC CAPITAL LETTER CROSSED O
+A722; C; A723; # LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF
+A724; C; A725; # LATIN CAPITAL LETTER EGYPTOLOGICAL AIN
+A726; C; A727; # LATIN CAPITAL LETTER HENG
+A728; C; A729; # LATIN CAPITAL LETTER TZ
+A72A; C; A72B; # LATIN CAPITAL LETTER TRESILLO
+A72C; C; A72D; # LATIN CAPITAL LETTER CUATRILLO
+A72E; C; A72F; # LATIN CAPITAL LETTER CUATRILLO WITH COMMA
+A732; C; A733; # LATIN CAPITAL LETTER AA
+A734; C; A735; # LATIN CAPITAL LETTER AO
+A736; C; A737; # LATIN CAPITAL LETTER AU
+A738; C; A739; # LATIN CAPITAL LETTER AV
+A73A; C; A73B; # LATIN CAPITAL LETTER AV WITH HORIZONTAL BAR
+A73C; C; A73D; # LATIN CAPITAL LETTER AY
+A73E; C; A73F; # LATIN CAPITAL LETTER REVERSED C WITH DOT
+A740; C; A741; # LATIN CAPITAL LETTER K WITH STROKE
+A742; C; A743; # LATIN CAPITAL LETTER K WITH DIAGONAL STROKE
+A744; C; A745; # LATIN CAPITAL LETTER K WITH STROKE AND DIAGONAL STROKE
+A746; C; A747; # LATIN CAPITAL LETTER BROKEN L
+A748; C; A749; # LATIN CAPITAL LETTER L WITH HIGH STROKE
+A74A; C; A74B; # LATIN CAPITAL LETTER O WITH LONG STROKE OVERLAY
+A74C; C; A74D; # LATIN CAPITAL LETTER O WITH LOOP
+A74E; C; A74F; # LATIN CAPITAL LETTER OO
+A750; C; A751; # LATIN CAPITAL LETTER P WITH STROKE THROUGH DESCENDER
+A752; C; A753; # LATIN CAPITAL LETTER P WITH FLOURISH
+A754; C; A755; # LATIN CAPITAL LETTER P WITH SQUIRREL TAIL
+A756; C; A757; # LATIN CAPITAL LETTER Q WITH STROKE THROUGH DESCENDER
+A758; C; A759; # LATIN CAPITAL LETTER Q WITH DIAGONAL STROKE
+A75A; C; A75B; # LATIN CAPITAL LETTER R ROTUNDA
+A75C; C; A75D; # LATIN CAPITAL LETTER RUM ROTUNDA
+A75E; C; A75F; # LATIN CAPITAL LETTER V WITH DIAGONAL STROKE
+A760; C; A761; # LATIN CAPITAL LETTER VY
+A762; C; A763; # LATIN CAPITAL LETTER VISIGOTHIC Z
+A764; C; A765; # LATIN CAPITAL LETTER THORN WITH STROKE
+A766; C; A767; # LATIN CAPITAL LETTER THORN WITH STROKE THROUGH DESCENDER
+A768; C; A769; # LATIN CAPITAL LETTER VEND
+A76A; C; A76B; # LATIN CAPITAL LETTER ET
+A76C; C; A76D; # LATIN CAPITAL LETTER IS
+A76E; C; A76F; # LATIN CAPITAL LETTER CON
+A779; C; A77A; # LATIN CAPITAL LETTER INSULAR D
+A77B; C; A77C; # LATIN CAPITAL LETTER INSULAR F
+A77D; C; 1D79; # LATIN CAPITAL LETTER INSULAR G
+A77E; C; A77F; # LATIN CAPITAL LETTER TURNED INSULAR G
+A780; C; A781; # LATIN CAPITAL LETTER TURNED L
+A782; C; A783; # LATIN CAPITAL LETTER INSULAR R
+A784; C; A785; # LATIN CAPITAL LETTER INSULAR S
+A786; C; A787; # LATIN CAPITAL LETTER INSULAR T
+A78B; C; A78C; # LATIN CAPITAL LETTER SALTILLO
+A78D; C; 0265; # LATIN CAPITAL LETTER TURNED H
+A790; C; A791; # LATIN CAPITAL LETTER N WITH DESCENDER
+A792; C; A793; # LATIN CAPITAL LETTER C WITH BAR
+A796; C; A797; # LATIN CAPITAL LETTER B WITH FLOURISH
+A798; C; A799; # LATIN CAPITAL LETTER F WITH STROKE
+A79A; C; A79B; # LATIN CAPITAL LETTER VOLAPUK AE
+A79C; C; A79D; # LATIN CAPITAL LETTER VOLAPUK OE
+A79E; C; A79F; # LATIN CAPITAL LETTER VOLAPUK UE
+A7A0; C; A7A1; # LATIN CAPITAL LETTER G WITH OBLIQUE STROKE
+A7A2; C; A7A3; # LATIN CAPITAL LETTER K WITH OBLIQUE STROKE
+A7A4; C; A7A5; # LATIN CAPITAL LETTER N WITH OBLIQUE STROKE
+A7A6; C; A7A7; # LATIN CAPITAL LETTER R WITH OBLIQUE STROKE
+A7A8; C; A7A9; # LATIN CAPITAL LETTER S WITH OBLIQUE STROKE
+A7AA; C; 0266; # LATIN CAPITAL LETTER H WITH HOOK
+A7AB; C; 025C; # LATIN CAPITAL LETTER REVERSED OPEN E
+A7AC; C; 0261; # LATIN CAPITAL LETTER SCRIPT G
+A7AD; C; 026C; # LATIN CAPITAL LETTER L WITH BELT
+A7AE; C; 026A; # LATIN CAPITAL LETTER SMALL CAPITAL I
+A7B0; C; 029E; # LATIN CAPITAL LETTER TURNED K
+A7B1; C; 0287; # LATIN CAPITAL LETTER TURNED T
+A7B2; C; 029D; # LATIN CAPITAL LETTER J WITH CROSSED-TAIL
+A7B3; C; AB53; # LATIN CAPITAL LETTER CHI
+A7B4; C; A7B5; # LATIN CAPITAL LETTER BETA
+A7B6; C; A7B7; # LATIN CAPITAL LETTER OMEGA
+A7B8; C; A7B9; # LATIN CAPITAL LETTER U WITH STROKE
+A7BA; C; A7BB; # LATIN CAPITAL LETTER GLOTTAL A
+A7BC; C; A7BD; # LATIN CAPITAL LETTER GLOTTAL I
+A7BE; C; A7BF; # LATIN CAPITAL LETTER GLOTTAL U
+A7C0; C; A7C1; # LATIN CAPITAL LETTER OLD POLISH O
+A7C2; C; A7C3; # LATIN CAPITAL LETTER ANGLICANA W
+A7C4; C; A794; # LATIN CAPITAL LETTER C WITH PALATAL HOOK
+A7C5; C; 0282; # LATIN CAPITAL LETTER S WITH HOOK
+A7C6; C; 1D8E; # LATIN CAPITAL LETTER Z WITH PALATAL HOOK
+A7C7; C; A7C8; # LATIN CAPITAL LETTER D WITH SHORT STROKE OVERLAY
+A7C9; C; A7CA; # LATIN CAPITAL LETTER S WITH SHORT STROKE OVERLAY
+A7CB; C; 0264; # LATIN CAPITAL LETTER RAMS HORN
+A7CC; C; A7CD; # LATIN CAPITAL LETTER S WITH DIAGONAL STROKE
+A7CE; C; A7CF; # LATIN CAPITAL LETTER PHARYNGEAL VOICED FRICATIVE
+A7D0; C; A7D1; # LATIN CAPITAL LETTER CLOSED INSULAR G
+A7D2; C; A7D3; # LATIN CAPITAL LETTER DOUBLE THORN
+A7D4; C; A7D5; # LATIN CAPITAL LETTER DOUBLE WYNN
+A7D6; C; A7D7; # LATIN CAPITAL LETTER MIDDLE SCOTS S
+A7D8; C; A7D9; # LATIN CAPITAL LETTER SIGMOID S
+A7DA; C; A7DB; # LATIN CAPITAL LETTER LAMBDA
+A7DC; C; 019B; # LATIN CAPITAL LETTER LAMBDA WITH STROKE
+A7F5; C; A7F6; # LATIN CAPITAL LETTER REVERSED HALF H
+AB70; C; 13A0; # CHEROKEE SMALL LETTER A
+AB71; C; 13A1; # CHEROKEE SMALL LETTER E
+AB72; C; 13A2; # CHEROKEE SMALL LETTER I
+AB73; C; 13A3; # CHEROKEE SMALL LETTER O
+AB74; C; 13A4; # CHEROKEE SMALL LETTER U
+AB75; C; 13A5; # CHEROKEE SMALL LETTER V
+AB76; C; 13A6; # CHEROKEE SMALL LETTER GA
+AB77; C; 13A7; # CHEROKEE SMALL LETTER KA
+AB78; C; 13A8; # CHEROKEE SMALL LETTER GE
+AB79; C; 13A9; # CHEROKEE SMALL LETTER GI
+AB7A; C; 13AA; # CHEROKEE SMALL LETTER GO
+AB7B; C; 13AB; # CHEROKEE SMALL LETTER GU
+AB7C; C; 13AC; # CHEROKEE SMALL LETTER GV
+AB7D; C; 13AD; # CHEROKEE SMALL LETTER HA
+AB7E; C; 13AE; # CHEROKEE SMALL LETTER HE
+AB7F; C; 13AF; # CHEROKEE SMALL LETTER HI
+AB80; C; 13B0; # CHEROKEE SMALL LETTER HO
+AB81; C; 13B1; # CHEROKEE SMALL LETTER HU
+AB82; C; 13B2; # CHEROKEE SMALL LETTER HV
+AB83; C; 13B3; # CHEROKEE SMALL LETTER LA
+AB84; C; 13B4; # CHEROKEE SMALL LETTER LE
+AB85; C; 13B5; # CHEROKEE SMALL LETTER LI
+AB86; C; 13B6; # CHEROKEE SMALL LETTER LO
+AB87; C; 13B7; # CHEROKEE SMALL LETTER LU
+AB88; C; 13B8; # CHEROKEE SMALL LETTER LV
+AB89; C; 13B9; # CHEROKEE SMALL LETTER MA
+AB8A; C; 13BA; # CHEROKEE SMALL LETTER ME
+AB8B; C; 13BB; # CHEROKEE SMALL LETTER MI
+AB8C; C; 13BC; # CHEROKEE SMALL LETTER MO
+AB8D; C; 13BD; # CHEROKEE SMALL LETTER MU
+AB8E; C; 13BE; # CHEROKEE SMALL LETTER NA
+AB8F; C; 13BF; # CHEROKEE SMALL LETTER HNA
+AB90; C; 13C0; # CHEROKEE SMALL LETTER NAH
+AB91; C; 13C1; # CHEROKEE SMALL LETTER NE
+AB92; C; 13C2; # CHEROKEE SMALL LETTER NI
+AB93; C; 13C3; # CHEROKEE SMALL LETTER NO
+AB94; C; 13C4; # CHEROKEE SMALL LETTER NU
+AB95; C; 13C5; # CHEROKEE SMALL LETTER NV
+AB96; C; 13C6; # CHEROKEE SMALL LETTER QUA
+AB97; C; 13C7; # CHEROKEE SMALL LETTER QUE
+AB98; C; 13C8; # CHEROKEE SMALL LETTER QUI
+AB99; C; 13C9; # CHEROKEE SMALL LETTER QUO
+AB9A; C; 13CA; # CHEROKEE SMALL LETTER QUU
+AB9B; C; 13CB; # CHEROKEE SMALL LETTER QUV
+AB9C; C; 13CC; # CHEROKEE SMALL LETTER SA
+AB9D; C; 13CD; # CHEROKEE SMALL LETTER S
+AB9E; C; 13CE; # CHEROKEE SMALL LETTER SE
+AB9F; C; 13CF; # CHEROKEE SMALL LETTER SI
+ABA0; C; 13D0; # CHEROKEE SMALL LETTER SO
+ABA1; C; 13D1; # CHEROKEE SMALL LETTER SU
+ABA2; C; 13D2; # CHEROKEE SMALL LETTER SV
+ABA3; C; 13D3; # CHEROKEE SMALL LETTER DA
+ABA4; C; 13D4; # CHEROKEE SMALL LETTER TA
+ABA5; C; 13D5; # CHEROKEE SMALL LETTER DE
+ABA6; C; 13D6; # CHEROKEE SMALL LETTER TE
+ABA7; C; 13D7; # CHEROKEE SMALL LETTER DI
+ABA8; C; 13D8; # CHEROKEE SMALL LETTER TI
+ABA9; C; 13D9; # CHEROKEE SMALL LETTER DO
+ABAA; C; 13DA; # CHEROKEE SMALL LETTER DU
+ABAB; C; 13DB; # CHEROKEE SMALL LETTER DV
+ABAC; C; 13DC; # CHEROKEE SMALL LETTER DLA
+ABAD; C; 13DD; # CHEROKEE SMALL LETTER TLA
+ABAE; C; 13DE; # CHEROKEE SMALL LETTER TLE
+ABAF; C; 13DF; # CHEROKEE SMALL LETTER TLI
+ABB0; C; 13E0; # CHEROKEE SMALL LETTER TLO
+ABB1; C; 13E1; # CHEROKEE SMALL LETTER TLU
+ABB2; C; 13E2; # CHEROKEE SMALL LETTER TLV
+ABB3; C; 13E3; # CHEROKEE SMALL LETTER TSA
+ABB4; C; 13E4; # CHEROKEE SMALL LETTER TSE
+ABB5; C; 13E5; # CHEROKEE SMALL LETTER TSI
+ABB6; C; 13E6; # CHEROKEE SMALL LETTER TSO
+ABB7; C; 13E7; # CHEROKEE SMALL LETTER TSU
+ABB8; C; 13E8; # CHEROKEE SMALL LETTER TSV
+ABB9; C; 13E9; # CHEROKEE SMALL LETTER WA
+ABBA; C; 13EA; # CHEROKEE SMALL LETTER WE
+ABBB; C; 13EB; # CHEROKEE SMALL LETTER WI
+ABBC; C; 13EC; # CHEROKEE SMALL LETTER WO
+ABBD; C; 13ED; # CHEROKEE SMALL LETTER WU
+ABBE; C; 13EE; # CHEROKEE SMALL LETTER WV
+ABBF; C; 13EF; # CHEROKEE SMALL LETTER YA
+FB00; F; 0066 0066; # LATIN SMALL LIGATURE FF
+FB01; F; 0066 0069; # LATIN SMALL LIGATURE FI
+FB02; F; 0066 006C; # LATIN SMALL LIGATURE FL
+FB03; F; 0066 0066 0069; # LATIN SMALL LIGATURE FFI
+FB04; F; 0066 0066 006C; # LATIN SMALL LIGATURE FFL
+FB05; F; 0073 0074; # LATIN SMALL LIGATURE LONG S T
+FB05; S; FB06; # LATIN SMALL LIGATURE LONG S T
+FB06; F; 0073 0074; # LATIN SMALL LIGATURE ST
+FB13; F; 0574 0576; # ARMENIAN SMALL LIGATURE MEN NOW
+FB14; F; 0574 0565; # ARMENIAN SMALL LIGATURE MEN ECH
+FB15; F; 0574 056B; # ARMENIAN SMALL LIGATURE MEN INI
+FB16; F; 057E 0576; # ARMENIAN SMALL LIGATURE VEW NOW
+FB17; F; 0574 056D; # ARMENIAN SMALL LIGATURE MEN XEH
+FF21; C; FF41; # FULLWIDTH LATIN CAPITAL LETTER A
+FF22; C; FF42; # FULLWIDTH LATIN CAPITAL LETTER B
+FF23; C; FF43; # FULLWIDTH LATIN CAPITAL LETTER C
+FF24; C; FF44; # FULLWIDTH LATIN CAPITAL LETTER D
+FF25; C; FF45; # FULLWIDTH LATIN CAPITAL LETTER E
+FF26; C; FF46; # FULLWIDTH LATIN CAPITAL LETTER F
+FF27; C; FF47; # FULLWIDTH LATIN CAPITAL LETTER G
+FF28; C; FF48; # FULLWIDTH LATIN CAPITAL LETTER H
+FF29; C; FF49; # FULLWIDTH LATIN CAPITAL LETTER I
+FF2A; C; FF4A; # FULLWIDTH LATIN CAPITAL LETTER J
+FF2B; C; FF4B; # FULLWIDTH LATIN CAPITAL LETTER K
+FF2C; C; FF4C; # FULLWIDTH LATIN CAPITAL LETTER L
+FF2D; C; FF4D; # FULLWIDTH LATIN CAPITAL LETTER M
+FF2E; C; FF4E; # FULLWIDTH LATIN CAPITAL LETTER N
+FF2F; C; FF4F; # FULLWIDTH LATIN CAPITAL LETTER O
+FF30; C; FF50; # FULLWIDTH LATIN CAPITAL LETTER P
+FF31; C; FF51; # FULLWIDTH LATIN CAPITAL LETTER Q
+FF32; C; FF52; # FULLWIDTH LATIN CAPITAL LETTER R
+FF33; C; FF53; # FULLWIDTH LATIN CAPITAL LETTER S
+FF34; C; FF54; # FULLWIDTH LATIN CAPITAL LETTER T
+FF35; C; FF55; # FULLWIDTH LATIN CAPITAL LETTER U
+FF36; C; FF56; # FULLWIDTH LATIN CAPITAL LETTER V
+FF37; C; FF57; # FULLWIDTH LATIN CAPITAL LETTER W
+FF38; C; FF58; # FULLWIDTH LATIN CAPITAL LETTER X
+FF39; C; FF59; # FULLWIDTH LATIN CAPITAL LETTER Y
+FF3A; C; FF5A; # FULLWIDTH LATIN CAPITAL LETTER Z
+10400; C; 10428; # DESERET CAPITAL LETTER LONG I
+10401; C; 10429; # DESERET CAPITAL LETTER LONG E
+10402; C; 1042A; # DESERET CAPITAL LETTER LONG A
+10403; C; 1042B; # DESERET CAPITAL LETTER LONG AH
+10404; C; 1042C; # DESERET CAPITAL LETTER LONG O
+10405; C; 1042D; # DESERET CAPITAL LETTER LONG OO
+10406; C; 1042E; # DESERET CAPITAL LETTER SHORT I
+10407; C; 1042F; # DESERET CAPITAL LETTER SHORT E
+10408; C; 10430; # DESERET CAPITAL LETTER SHORT A
+10409; C; 10431; # DESERET CAPITAL LETTER SHORT AH
+1040A; C; 10432; # DESERET CAPITAL LETTER SHORT O
+1040B; C; 10433; # DESERET CAPITAL LETTER SHORT OO
+1040C; C; 10434; # DESERET CAPITAL LETTER AY
+1040D; C; 10435; # DESERET CAPITAL LETTER OW
+1040E; C; 10436; # DESERET CAPITAL LETTER WU
+1040F; C; 10437; # DESERET CAPITAL LETTER YEE
+10410; C; 10438; # DESERET CAPITAL LETTER H
+10411; C; 10439; # DESERET CAPITAL LETTER PEE
+10412; C; 1043A; # DESERET CAPITAL LETTER BEE
+10413; C; 1043B; # DESERET CAPITAL LETTER TEE
+10414; C; 1043C; # DESERET CAPITAL LETTER DEE
+10415; C; 1043D; # DESERET CAPITAL LETTER CHEE
+10416; C; 1043E; # DESERET CAPITAL LETTER JEE
+10417; C; 1043F; # DESERET CAPITAL LETTER KAY
+10418; C; 10440; # DESERET CAPITAL LETTER GAY
+10419; C; 10441; # DESERET CAPITAL LETTER EF
+1041A; C; 10442; # DESERET CAPITAL LETTER VEE
+1041B; C; 10443; # DESERET CAPITAL LETTER ETH
+1041C; C; 10444; # DESERET CAPITAL LETTER THEE
+1041D; C; 10445; # DESERET CAPITAL LETTER ES
+1041E; C; 10446; # DESERET CAPITAL LETTER ZEE
+1041F; C; 10447; # DESERET CAPITAL LETTER ESH
+10420; C; 10448; # DESERET CAPITAL LETTER ZHEE
+10421; C; 10449; # DESERET CAPITAL LETTER ER
+10422; C; 1044A; # DESERET CAPITAL LETTER EL
+10423; C; 1044B; # DESERET CAPITAL LETTER EM
+10424; C; 1044C; # DESERET CAPITAL LETTER EN
+10425; C; 1044D; # DESERET CAPITAL LETTER ENG
+10426; C; 1044E; # DESERET CAPITAL LETTER OI
+10427; C; 1044F; # DESERET CAPITAL LETTER EW
+104B0; C; 104D8; # OSAGE CAPITAL LETTER A
+104B1; C; 104D9; # OSAGE CAPITAL LETTER AI
+104B2; C; 104DA; # OSAGE CAPITAL LETTER AIN
+104B3; C; 104DB; # OSAGE CAPITAL LETTER AH
+104B4; C; 104DC; # OSAGE CAPITAL LETTER BRA
+104B5; C; 104DD; # OSAGE CAPITAL LETTER CHA
+104B6; C; 104DE; # OSAGE CAPITAL LETTER EHCHA
+104B7; C; 104DF; # OSAGE CAPITAL LETTER E
+104B8; C; 104E0; # OSAGE CAPITAL LETTER EIN
+104B9; C; 104E1; # OSAGE CAPITAL LETTER HA
+104BA; C; 104E2; # OSAGE CAPITAL LETTER HYA
+104BB; C; 104E3; # OSAGE CAPITAL LETTER I
+104BC; C; 104E4; # OSAGE CAPITAL LETTER KA
+104BD; C; 104E5; # OSAGE CAPITAL LETTER EHKA
+104BE; C; 104E6; # OSAGE CAPITAL LETTER KYA
+104BF; C; 104E7; # OSAGE CAPITAL LETTER LA
+104C0; C; 104E8; # OSAGE CAPITAL LETTER MA
+104C1; C; 104E9; # OSAGE CAPITAL LETTER NA
+104C2; C; 104EA; # OSAGE CAPITAL LETTER O
+104C3; C; 104EB; # OSAGE CAPITAL LETTER OIN
+104C4; C; 104EC; # OSAGE CAPITAL LETTER PA
+104C5; C; 104ED; # OSAGE CAPITAL LETTER EHPA
+104C6; C; 104EE; # OSAGE CAPITAL LETTER SA
+104C7; C; 104EF; # OSAGE CAPITAL LETTER SHA
+104C8; C; 104F0; # OSAGE CAPITAL LETTER TA
+104C9; C; 104F1; # OSAGE CAPITAL LETTER EHTA
+104CA; C; 104F2; # OSAGE CAPITAL LETTER TSA
+104CB; C; 104F3; # OSAGE CAPITAL LETTER EHTSA
+104CC; C; 104F4; # OSAGE CAPITAL LETTER TSHA
+104CD; C; 104F5; # OSAGE CAPITAL LETTER DHA
+104CE; C; 104F6; # OSAGE CAPITAL LETTER U
+104CF; C; 104F7; # OSAGE CAPITAL LETTER WA
+104D0; C; 104F8; # OSAGE CAPITAL LETTER KHA
+104D1; C; 104F9; # OSAGE CAPITAL LETTER GHA
+104D2; C; 104FA; # OSAGE CAPITAL LETTER ZA
+104D3; C; 104FB; # OSAGE CAPITAL LETTER ZHA
+10570; C; 10597; # VITHKUQI CAPITAL LETTER A
+10571; C; 10598; # VITHKUQI CAPITAL LETTER BBE
+10572; C; 10599; # VITHKUQI CAPITAL LETTER BE
+10573; C; 1059A; # VITHKUQI CAPITAL LETTER CE
+10574; C; 1059B; # VITHKUQI CAPITAL LETTER CHE
+10575; C; 1059C; # VITHKUQI CAPITAL LETTER DE
+10576; C; 1059D; # VITHKUQI CAPITAL LETTER DHE
+10577; C; 1059E; # VITHKUQI CAPITAL LETTER EI
+10578; C; 1059F; # VITHKUQI CAPITAL LETTER E
+10579; C; 105A0; # VITHKUQI CAPITAL LETTER FE
+1057A; C; 105A1; # VITHKUQI CAPITAL LETTER GA
+1057C; C; 105A3; # VITHKUQI CAPITAL LETTER HA
+1057D; C; 105A4; # VITHKUQI CAPITAL LETTER HHA
+1057E; C; 105A5; # VITHKUQI CAPITAL LETTER I
+1057F; C; 105A6; # VITHKUQI CAPITAL LETTER IJE
+10580; C; 105A7; # VITHKUQI CAPITAL LETTER JE
+10581; C; 105A8; # VITHKUQI CAPITAL LETTER KA
+10582; C; 105A9; # VITHKUQI CAPITAL LETTER LA
+10583; C; 105AA; # VITHKUQI CAPITAL LETTER LLA
+10584; C; 105AB; # VITHKUQI CAPITAL LETTER ME
+10585; C; 105AC; # VITHKUQI CAPITAL LETTER NE
+10586; C; 105AD; # VITHKUQI CAPITAL LETTER NJE
+10587; C; 105AE; # VITHKUQI CAPITAL LETTER O
+10588; C; 105AF; # VITHKUQI CAPITAL LETTER PE
+10589; C; 105B0; # VITHKUQI CAPITAL LETTER QA
+1058A; C; 105B1; # VITHKUQI CAPITAL LETTER RE
+1058C; C; 105B3; # VITHKUQI CAPITAL LETTER SE
+1058D; C; 105B4; # VITHKUQI CAPITAL LETTER SHE
+1058E; C; 105B5; # VITHKUQI CAPITAL LETTER TE
+1058F; C; 105B6; # VITHKUQI CAPITAL LETTER THE
+10590; C; 105B7; # VITHKUQI CAPITAL LETTER U
+10591; C; 105B8; # VITHKUQI CAPITAL LETTER VE
+10592; C; 105B9; # VITHKUQI CAPITAL LETTER XE
+10594; C; 105BB; # VITHKUQI CAPITAL LETTER Y
+10595; C; 105BC; # VITHKUQI CAPITAL LETTER ZE
+10C80; C; 10CC0; # OLD HUNGARIAN CAPITAL LETTER A
+10C81; C; 10CC1; # OLD HUNGARIAN CAPITAL LETTER AA
+10C82; C; 10CC2; # OLD HUNGARIAN CAPITAL LETTER EB
+10C83; C; 10CC3; # OLD HUNGARIAN CAPITAL LETTER AMB
+10C84; C; 10CC4; # OLD HUNGARIAN CAPITAL LETTER EC
+10C85; C; 10CC5; # OLD HUNGARIAN CAPITAL LETTER ENC
+10C86; C; 10CC6; # OLD HUNGARIAN CAPITAL LETTER ECS
+10C87; C; 10CC7; # OLD HUNGARIAN CAPITAL LETTER ED
+10C88; C; 10CC8; # OLD HUNGARIAN CAPITAL LETTER AND
+10C89; C; 10CC9; # OLD HUNGARIAN CAPITAL LETTER E
+10C8A; C; 10CCA; # OLD HUNGARIAN CAPITAL LETTER CLOSE E
+10C8B; C; 10CCB; # OLD HUNGARIAN CAPITAL LETTER EE
+10C8C; C; 10CCC; # OLD HUNGARIAN CAPITAL LETTER EF
+10C8D; C; 10CCD; # OLD HUNGARIAN CAPITAL LETTER EG
+10C8E; C; 10CCE; # OLD HUNGARIAN CAPITAL LETTER EGY
+10C8F; C; 10CCF; # OLD HUNGARIAN CAPITAL LETTER EH
+10C90; C; 10CD0; # OLD HUNGARIAN CAPITAL LETTER I
+10C91; C; 10CD1; # OLD HUNGARIAN CAPITAL LETTER II
+10C92; C; 10CD2; # OLD HUNGARIAN CAPITAL LETTER EJ
+10C93; C; 10CD3; # OLD HUNGARIAN CAPITAL LETTER EK
+10C94; C; 10CD4; # OLD HUNGARIAN CAPITAL LETTER AK
+10C95; C; 10CD5; # OLD HUNGARIAN CAPITAL LETTER UNK
+10C96; C; 10CD6; # OLD HUNGARIAN CAPITAL LETTER EL
+10C97; C; 10CD7; # OLD HUNGARIAN CAPITAL LETTER ELY
+10C98; C; 10CD8; # OLD HUNGARIAN CAPITAL LETTER EM
+10C99; C; 10CD9; # OLD HUNGARIAN CAPITAL LETTER EN
+10C9A; C; 10CDA; # OLD HUNGARIAN CAPITAL LETTER ENY
+10C9B; C; 10CDB; # OLD HUNGARIAN CAPITAL LETTER O
+10C9C; C; 10CDC; # OLD HUNGARIAN CAPITAL LETTER OO
+10C9D; C; 10CDD; # OLD HUNGARIAN CAPITAL LETTER NIKOLSBURG OE
+10C9E; C; 10CDE; # OLD HUNGARIAN CAPITAL LETTER RUDIMENTA OE
+10C9F; C; 10CDF; # OLD HUNGARIAN CAPITAL LETTER OEE
+10CA0; C; 10CE0; # OLD HUNGARIAN CAPITAL LETTER EP
+10CA1; C; 10CE1; # OLD HUNGARIAN CAPITAL LETTER EMP
+10CA2; C; 10CE2; # OLD HUNGARIAN CAPITAL LETTER ER
+10CA3; C; 10CE3; # OLD HUNGARIAN CAPITAL LETTER SHORT ER
+10CA4; C; 10CE4; # OLD HUNGARIAN CAPITAL LETTER ES
+10CA5; C; 10CE5; # OLD HUNGARIAN CAPITAL LETTER ESZ
+10CA6; C; 10CE6; # OLD HUNGARIAN CAPITAL LETTER ET
+10CA7; C; 10CE7; # OLD HUNGARIAN CAPITAL LETTER ENT
+10CA8; C; 10CE8; # OLD HUNGARIAN CAPITAL LETTER ETY
+10CA9; C; 10CE9; # OLD HUNGARIAN CAPITAL LETTER ECH
+10CAA; C; 10CEA; # OLD HUNGARIAN CAPITAL LETTER U
+10CAB; C; 10CEB; # OLD HUNGARIAN CAPITAL LETTER UU
+10CAC; C; 10CEC; # OLD HUNGARIAN CAPITAL LETTER NIKOLSBURG UE
+10CAD; C; 10CED; # OLD HUNGARIAN CAPITAL LETTER RUDIMENTA UE
+10CAE; C; 10CEE; # OLD HUNGARIAN CAPITAL LETTER EV
+10CAF; C; 10CEF; # OLD HUNGARIAN CAPITAL LETTER EZ
+10CB0; C; 10CF0; # OLD HUNGARIAN CAPITAL LETTER EZS
+10CB1; C; 10CF1; # OLD HUNGARIAN CAPITAL LETTER ENT-SHAPED SIGN
+10CB2; C; 10CF2; # OLD HUNGARIAN CAPITAL LETTER US
+10D50; C; 10D70; # GARAY CAPITAL LETTER A
+10D51; C; 10D71; # GARAY CAPITAL LETTER CA
+10D52; C; 10D72; # GARAY CAPITAL LETTER MA
+10D53; C; 10D73; # GARAY CAPITAL LETTER KA
+10D54; C; 10D74; # GARAY CAPITAL LETTER BA
+10D55; C; 10D75; # GARAY CAPITAL LETTER JA
+10D56; C; 10D76; # GARAY CAPITAL LETTER SA
+10D57; C; 10D77; # GARAY CAPITAL LETTER WA
+10D58; C; 10D78; # GARAY CAPITAL LETTER LA
+10D59; C; 10D79; # GARAY CAPITAL LETTER GA
+10D5A; C; 10D7A; # GARAY CAPITAL LETTER DA
+10D5B; C; 10D7B; # GARAY CAPITAL LETTER XA
+10D5C; C; 10D7C; # GARAY CAPITAL LETTER YA
+10D5D; C; 10D7D; # GARAY CAPITAL LETTER TA
+10D5E; C; 10D7E; # GARAY CAPITAL LETTER RA
+10D5F; C; 10D7F; # GARAY CAPITAL LETTER NYA
+10D60; C; 10D80; # GARAY CAPITAL LETTER FA
+10D61; C; 10D81; # GARAY CAPITAL LETTER NA
+10D62; C; 10D82; # GARAY CAPITAL LETTER PA
+10D63; C; 10D83; # GARAY CAPITAL LETTER HA
+10D64; C; 10D84; # GARAY CAPITAL LETTER OLD KA
+10D65; C; 10D85; # GARAY CAPITAL LETTER OLD NA
+118A0; C; 118C0; # WARANG CITI CAPITAL LETTER NGAA
+118A1; C; 118C1; # WARANG CITI CAPITAL LETTER A
+118A2; C; 118C2; # WARANG CITI CAPITAL LETTER WI
+118A3; C; 118C3; # WARANG CITI CAPITAL LETTER YU
+118A4; C; 118C4; # WARANG CITI CAPITAL LETTER YA
+118A5; C; 118C5; # WARANG CITI CAPITAL LETTER YO
+118A6; C; 118C6; # WARANG CITI CAPITAL LETTER II
+118A7; C; 118C7; # WARANG CITI CAPITAL LETTER UU
+118A8; C; 118C8; # WARANG CITI CAPITAL LETTER E
+118A9; C; 118C9; # WARANG CITI CAPITAL LETTER O
+118AA; C; 118CA; # WARANG CITI CAPITAL LETTER ANG
+118AB; C; 118CB; # WARANG CITI CAPITAL LETTER GA
+118AC; C; 118CC; # WARANG CITI CAPITAL LETTER KO
+118AD; C; 118CD; # WARANG CITI CAPITAL LETTER ENY
+118AE; C; 118CE; # WARANG CITI CAPITAL LETTER YUJ
+118AF; C; 118CF; # WARANG CITI CAPITAL LETTER UC
+118B0; C; 118D0; # WARANG CITI CAPITAL LETTER ENN
+118B1; C; 118D1; # WARANG CITI CAPITAL LETTER ODD
+118B2; C; 118D2; # WARANG CITI CAPITAL LETTER TTE
+118B3; C; 118D3; # WARANG CITI CAPITAL LETTER NUNG
+118B4; C; 118D4; # WARANG CITI CAPITAL LETTER DA
+118B5; C; 118D5; # WARANG CITI CAPITAL LETTER AT
+118B6; C; 118D6; # WARANG CITI CAPITAL LETTER AM
+118B7; C; 118D7; # WARANG CITI CAPITAL LETTER BU
+118B8; C; 118D8; # WARANG CITI CAPITAL LETTER PU
+118B9; C; 118D9; # WARANG CITI CAPITAL LETTER HIYO
+118BA; C; 118DA; # WARANG CITI CAPITAL LETTER HOLO
+118BB; C; 118DB; # WARANG CITI CAPITAL LETTER HORR
+118BC; C; 118DC; # WARANG CITI CAPITAL LETTER HAR
+118BD; C; 118DD; # WARANG CITI CAPITAL LETTER SSUU
+118BE; C; 118DE; # WARANG CITI CAPITAL LETTER SII
+118BF; C; 118DF; # WARANG CITI CAPITAL LETTER VIYO
+16E40; C; 16E60; # MEDEFAIDRIN CAPITAL LETTER M
+16E41; C; 16E61; # MEDEFAIDRIN CAPITAL LETTER S
+16E42; C; 16E62; # MEDEFAIDRIN CAPITAL LETTER V
+16E43; C; 16E63; # MEDEFAIDRIN CAPITAL LETTER W
+16E44; C; 16E64; # MEDEFAIDRIN CAPITAL LETTER ATIU
+16E45; C; 16E65; # MEDEFAIDRIN CAPITAL LETTER Z
+16E46; C; 16E66; # MEDEFAIDRIN CAPITAL LETTER KP
+16E47; C; 16E67; # MEDEFAIDRIN CAPITAL LETTER P
+16E48; C; 16E68; # MEDEFAIDRIN CAPITAL LETTER T
+16E49; C; 16E69; # MEDEFAIDRIN CAPITAL LETTER G
+16E4A; C; 16E6A; # MEDEFAIDRIN CAPITAL LETTER F
+16E4B; C; 16E6B; # MEDEFAIDRIN CAPITAL LETTER I
+16E4C; C; 16E6C; # MEDEFAIDRIN CAPITAL LETTER K
+16E4D; C; 16E6D; # MEDEFAIDRIN CAPITAL LETTER A
+16E4E; C; 16E6E; # MEDEFAIDRIN CAPITAL LETTER J
+16E4F; C; 16E6F; # MEDEFAIDRIN CAPITAL LETTER E
+16E50; C; 16E70; # MEDEFAIDRIN CAPITAL LETTER B
+16E51; C; 16E71; # MEDEFAIDRIN CAPITAL LETTER C
+16E52; C; 16E72; # MEDEFAIDRIN CAPITAL LETTER U
+16E53; C; 16E73; # MEDEFAIDRIN CAPITAL LETTER YU
+16E54; C; 16E74; # MEDEFAIDRIN CAPITAL LETTER L
+16E55; C; 16E75; # MEDEFAIDRIN CAPITAL LETTER Q
+16E56; C; 16E76; # MEDEFAIDRIN CAPITAL LETTER HP
+16E57; C; 16E77; # MEDEFAIDRIN CAPITAL LETTER NY
+16E58; C; 16E78; # MEDEFAIDRIN CAPITAL LETTER X
+16E59; C; 16E79; # MEDEFAIDRIN CAPITAL LETTER D
+16E5A; C; 16E7A; # MEDEFAIDRIN CAPITAL LETTER OE
+16E5B; C; 16E7B; # MEDEFAIDRIN CAPITAL LETTER N
+16E5C; C; 16E7C; # MEDEFAIDRIN CAPITAL LETTER R
+16E5D; C; 16E7D; # MEDEFAIDRIN CAPITAL LETTER O
+16E5E; C; 16E7E; # MEDEFAIDRIN CAPITAL LETTER AI
+16E5F; C; 16E7F; # MEDEFAIDRIN CAPITAL LETTER Y
+16EA0; C; 16EBB; # BERIA ERFE CAPITAL LETTER ARKAB
+16EA1; C; 16EBC; # BERIA ERFE CAPITAL LETTER BASIGNA
+16EA2; C; 16EBD; # BERIA ERFE CAPITAL LETTER DARBAI
+16EA3; C; 16EBE; # BERIA ERFE CAPITAL LETTER EH
+16EA4; C; 16EBF; # BERIA ERFE CAPITAL LETTER FITKO
+16EA5; C; 16EC0; # BERIA ERFE CAPITAL LETTER GOWAY
+16EA6; C; 16EC1; # BERIA ERFE CAPITAL LETTER HIRDEABO
+16EA7; C; 16EC2; # BERIA ERFE CAPITAL LETTER I
+16EA8; C; 16EC3; # BERIA ERFE CAPITAL LETTER DJAI
+16EA9; C; 16EC4; # BERIA ERFE CAPITAL LETTER KOBO
+16EAA; C; 16EC5; # BERIA ERFE CAPITAL LETTER LAKKO
+16EAB; C; 16EC6; # BERIA ERFE CAPITAL LETTER MERI
+16EAC; C; 16EC7; # BERIA ERFE CAPITAL LETTER NINI
+16EAD; C; 16EC8; # BERIA ERFE CAPITAL LETTER GNA
+16EAE; C; 16EC9; # BERIA ERFE CAPITAL LETTER NGAY
+16EAF; C; 16ECA; # BERIA ERFE CAPITAL LETTER OI
+16EB0; C; 16ECB; # BERIA ERFE CAPITAL LETTER PI
+16EB1; C; 16ECC; # BERIA ERFE CAPITAL LETTER ERIGO
+16EB2; C; 16ECD; # BERIA ERFE CAPITAL LETTER ERIGO TAMURA
+16EB3; C; 16ECE; # BERIA ERFE CAPITAL LETTER SERI
+16EB4; C; 16ECF; # BERIA ERFE CAPITAL LETTER SHEP
+16EB5; C; 16ED0; # BERIA ERFE CAPITAL LETTER TATASOUE
+16EB6; C; 16ED1; # BERIA ERFE CAPITAL LETTER UI
+16EB7; C; 16ED2; # BERIA ERFE CAPITAL LETTER WASSE
+16EB8; C; 16ED3; # BERIA ERFE CAPITAL LETTER AY
+1E900; C; 1E922; # ADLAM CAPITAL LETTER ALIF
+1E901; C; 1E923; # ADLAM CAPITAL LETTER DAALI
+1E902; C; 1E924; # ADLAM CAPITAL LETTER LAAM
+1E903; C; 1E925; # ADLAM CAPITAL LETTER MIIM
+1E904; C; 1E926; # ADLAM CAPITAL LETTER BA
+1E905; C; 1E927; # ADLAM CAPITAL LETTER SINNYIIYHE
+1E906; C; 1E928; # ADLAM CAPITAL LETTER PE
+1E907; C; 1E929; # ADLAM CAPITAL LETTER BHE
+1E908; C; 1E92A; # ADLAM CAPITAL LETTER RA
+1E909; C; 1E92B; # ADLAM CAPITAL LETTER E
+1E90A; C; 1E92C; # ADLAM CAPITAL LETTER FA
+1E90B; C; 1E92D; # ADLAM CAPITAL LETTER I
+1E90C; C; 1E92E; # ADLAM CAPITAL LETTER O
+1E90D; C; 1E92F; # ADLAM CAPITAL LETTER DHA
+1E90E; C; 1E930; # ADLAM CAPITAL LETTER YHE
+1E90F; C; 1E931; # ADLAM CAPITAL LETTER WAW
+1E910; C; 1E932; # ADLAM CAPITAL LETTER NUN
+1E911; C; 1E933; # ADLAM CAPITAL LETTER KAF
+1E912; C; 1E934; # ADLAM CAPITAL LETTER YA
+1E913; C; 1E935; # ADLAM CAPITAL LETTER U
+1E914; C; 1E936; # ADLAM CAPITAL LETTER JIIM
+1E915; C; 1E937; # ADLAM CAPITAL LETTER CHI
+1E916; C; 1E938; # ADLAM CAPITAL LETTER HA
+1E917; C; 1E939; # ADLAM CAPITAL LETTER QAAF
+1E918; C; 1E93A; # ADLAM CAPITAL LETTER GA
+1E919; C; 1E93B; # ADLAM CAPITAL LETTER NYA
+1E91A; C; 1E93C; # ADLAM CAPITAL LETTER TU
+1E91B; C; 1E93D; # ADLAM CAPITAL LETTER NHA
+1E91C; C; 1E93E; # ADLAM CAPITAL LETTER VA
+1E91D; C; 1E93F; # ADLAM CAPITAL LETTER KHA
+1E91E; C; 1E940; # ADLAM CAPITAL LETTER GBE
+1E91F; C; 1E941; # ADLAM CAPITAL LETTER ZAL
+1E920; C; 1E942; # ADLAM CAPITAL LETTER KPO
+1E921; C; 1E943; # ADLAM CAPITAL LETTER SHA
+#
+# EOF
diff --git a/vendor/core/vendor/whatwg-html-build/LICENSE b/vendor/core/vendor/whatwg-html-build/LICENSE
new file mode 100644
index 00000000..f2dcda46
--- /dev/null
+++ b/vendor/core/vendor/whatwg-html-build/LICENSE
@@ -0,0 +1,356 @@
+Copyright © WHATWG (Apple, Google, Mozilla, Microsoft).
+
+This work is licensed under a Creative Commons Attribution 4.0 International
+License. To the extent portions of it are incorporated into source code,
+such portions in the source code are licensed under the BSD 3-Clause License instead.
+
+- - - -
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+- - - -
+
+BSD 3-Clause License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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/vendor/core/vendor/whatwg-html-build/entities/out/entities.json b/vendor/core/vendor/whatwg-html-build/entities/out/entities.json
new file mode 100644
index 00000000..557170b4
--- /dev/null
+++ b/vendor/core/vendor/whatwg-html-build/entities/out/entities.json
@@ -0,0 +1,2233 @@
+{
+  "&AElig": { "codepoints": [198], "characters": "\u00C6" },
+  "&AElig;": { "codepoints": [198], "characters": "\u00C6" },
+  "&AMP": { "codepoints": [38], "characters": "\u0026" },
+  "&AMP;": { "codepoints": [38], "characters": "\u0026" },
+  "&Aacute": { "codepoints": [193], "characters": "\u00C1" },
+  "&Aacute;": { "codepoints": [193], "characters": "\u00C1" },
+  "&Abreve;": { "codepoints": [258], "characters": "\u0102" },
+  "&Acirc": { "codepoints": [194], "characters": "\u00C2" },
+  "&Acirc;": { "codepoints": [194], "characters": "\u00C2" },
+  "&Acy;": { "codepoints": [1040], "characters": "\u0410" },
+  "&Afr;": { "codepoints": [120068], "characters": "\uD835\uDD04" },
+  "&Agrave": { "codepoints": [192], "characters": "\u00C0" },
+  "&Agrave;": { "codepoints": [192], "characters": "\u00C0" },
+  "&Alpha;": { "codepoints": [913], "characters": "\u0391" },
+  "&Amacr;": { "codepoints": [256], "characters": "\u0100" },
+  "&And;": { "codepoints": [10835], "characters": "\u2A53" },
+  "&Aogon;": { "codepoints": [260], "characters": "\u0104" },
+  "&Aopf;": { "codepoints": [120120], "characters": "\uD835\uDD38" },
+  "&ApplyFunction;": { "codepoints": [8289], "characters": "\u2061" },
+  "&Aring": { "codepoints": [197], "characters": "\u00C5" },
+  "&Aring;": { "codepoints": [197], "characters": "\u00C5" },
+  "&Ascr;": { "codepoints": [119964], "characters": "\uD835\uDC9C" },
+  "&Assign;": { "codepoints": [8788], "characters": "\u2254" },
+  "&Atilde": { "codepoints": [195], "characters": "\u00C3" },
+  "&Atilde;": { "codepoints": [195], "characters": "\u00C3" },
+  "&Auml": { "codepoints": [196], "characters": "\u00C4" },
+  "&Auml;": { "codepoints": [196], "characters": "\u00C4" },
+  "&Backslash;": { "codepoints": [8726], "characters": "\u2216" },
+  "&Barv;": { "codepoints": [10983], "characters": "\u2AE7" },
+  "&Barwed;": { "codepoints": [8966], "characters": "\u2306" },
+  "&Bcy;": { "codepoints": [1041], "characters": "\u0411" },
+  "&Because;": { "codepoints": [8757], "characters": "\u2235" },
+  "&Bernoullis;": { "codepoints": [8492], "characters": "\u212C" },
+  "&Beta;": { "codepoints": [914], "characters": "\u0392" },
+  "&Bfr;": { "codepoints": [120069], "characters": "\uD835\uDD05" },
+  "&Bopf;": { "codepoints": [120121], "characters": "\uD835\uDD39" },
+  "&Breve;": { "codepoints": [728], "characters": "\u02D8" },
+  "&Bscr;": { "codepoints": [8492], "characters": "\u212C" },
+  "&Bumpeq;": { "codepoints": [8782], "characters": "\u224E" },
+  "&CHcy;": { "codepoints": [1063], "characters": "\u0427" },
+  "&COPY": { "codepoints": [169], "characters": "\u00A9" },
+  "&COPY;": { "codepoints": [169], "characters": "\u00A9" },
+  "&Cacute;": { "codepoints": [262], "characters": "\u0106" },
+  "&Cap;": { "codepoints": [8914], "characters": "\u22D2" },
+  "&CapitalDifferentialD;": { "codepoints": [8517], "characters": "\u2145" },
+  "&Cayleys;": { "codepoints": [8493], "characters": "\u212D" },
+  "&Ccaron;": { "codepoints": [268], "characters": "\u010C" },
+  "&Ccedil": { "codepoints": [199], "characters": "\u00C7" },
+  "&Ccedil;": { "codepoints": [199], "characters": "\u00C7" },
+  "&Ccirc;": { "codepoints": [264], "characters": "\u0108" },
+  "&Cconint;": { "codepoints": [8752], "characters": "\u2230" },
+  "&Cdot;": { "codepoints": [266], "characters": "\u010A" },
+  "&Cedilla;": { "codepoints": [184], "characters": "\u00B8" },
+  "&CenterDot;": { "codepoints": [183], "characters": "\u00B7" },
+  "&Cfr;": { "codepoints": [8493], "characters": "\u212D" },
+  "&Chi;": { "codepoints": [935], "characters": "\u03A7" },
+  "&CircleDot;": { "codepoints": [8857], "characters": "\u2299" },
+  "&CircleMinus;": { "codepoints": [8854], "characters": "\u2296" },
+  "&CirclePlus;": { "codepoints": [8853], "characters": "\u2295" },
+  "&CircleTimes;": { "codepoints": [8855], "characters": "\u2297" },
+  "&ClockwiseContourIntegral;": { "codepoints": [8754], "characters": "\u2232" },
+  "&CloseCurlyDoubleQuote;": { "codepoints": [8221], "characters": "\u201D" },
+  "&CloseCurlyQuote;": { "codepoints": [8217], "characters": "\u2019" },
+  "&Colon;": { "codepoints": [8759], "characters": "\u2237" },
+  "&Colone;": { "codepoints": [10868], "characters": "\u2A74" },
+  "&Congruent;": { "codepoints": [8801], "characters": "\u2261" },
+  "&Conint;": { "codepoints": [8751], "characters": "\u222F" },
+  "&ContourIntegral;": { "codepoints": [8750], "characters": "\u222E" },
+  "&Copf;": { "codepoints": [8450], "characters": "\u2102" },
+  "&Coproduct;": { "codepoints": [8720], "characters": "\u2210" },
+  "&CounterClockwiseContourIntegral;": { "codepoints": [8755], "characters": "\u2233" },
+  "&Cross;": { "codepoints": [10799], "characters": "\u2A2F" },
+  "&Cscr;": { "codepoints": [119966], "characters": "\uD835\uDC9E" },
+  "&Cup;": { "codepoints": [8915], "characters": "\u22D3" },
+  "&CupCap;": { "codepoints": [8781], "characters": "\u224D" },
+  "&DD;": { "codepoints": [8517], "characters": "\u2145" },
+  "&DDotrahd;": { "codepoints": [10513], "characters": "\u2911" },
+  "&DJcy;": { "codepoints": [1026], "characters": "\u0402" },
+  "&DScy;": { "codepoints": [1029], "characters": "\u0405" },
+  "&DZcy;": { "codepoints": [1039], "characters": "\u040F" },
+  "&Dagger;": { "codepoints": [8225], "characters": "\u2021" },
+  "&Darr;": { "codepoints": [8609], "characters": "\u21A1" },
+  "&Dashv;": { "codepoints": [10980], "characters": "\u2AE4" },
+  "&Dcaron;": { "codepoints": [270], "characters": "\u010E" },
+  "&Dcy;": { "codepoints": [1044], "characters": "\u0414" },
+  "&Del;": { "codepoints": [8711], "characters": "\u2207" },
+  "&Delta;": { "codepoints": [916], "characters": "\u0394" },
+  "&Dfr;": { "codepoints": [120071], "characters": "\uD835\uDD07" },
+  "&DiacriticalAcute;": { "codepoints": [180], "characters": "\u00B4" },
+  "&DiacriticalDot;": { "codepoints": [729], "characters": "\u02D9" },
+  "&DiacriticalDoubleAcute;": { "codepoints": [733], "characters": "\u02DD" },
+  "&DiacriticalGrave;": { "codepoints": [96], "characters": "\u0060" },
+  "&DiacriticalTilde;": { "codepoints": [732], "characters": "\u02DC" },
+  "&Diamond;": { "codepoints": [8900], "characters": "\u22C4" },
+  "&DifferentialD;": { "codepoints": [8518], "characters": "\u2146" },
+  "&Dopf;": { "codepoints": [120123], "characters": "\uD835\uDD3B" },
+  "&Dot;": { "codepoints": [168], "characters": "\u00A8" },
+  "&DotDot;": { "codepoints": [8412], "characters": "\u20DC" },
+  "&DotEqual;": { "codepoints": [8784], "characters": "\u2250" },
+  "&DoubleContourIntegral;": { "codepoints": [8751], "characters": "\u222F" },
+  "&DoubleDot;": { "codepoints": [168], "characters": "\u00A8" },
+  "&DoubleDownArrow;": { "codepoints": [8659], "characters": "\u21D3" },
+  "&DoubleLeftArrow;": { "codepoints": [8656], "characters": "\u21D0" },
+  "&DoubleLeftRightArrow;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&DoubleLeftTee;": { "codepoints": [10980], "characters": "\u2AE4" },
+  "&DoubleLongLeftArrow;": { "codepoints": [10232], "characters": "\u27F8" },
+  "&DoubleLongLeftRightArrow;": { "codepoints": [10234], "characters": "\u27FA" },
+  "&DoubleLongRightArrow;": { "codepoints": [10233], "characters": "\u27F9" },
+  "&DoubleRightArrow;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&DoubleRightTee;": { "codepoints": [8872], "characters": "\u22A8" },
+  "&DoubleUpArrow;": { "codepoints": [8657], "characters": "\u21D1" },
+  "&DoubleUpDownArrow;": { "codepoints": [8661], "characters": "\u21D5" },
+  "&DoubleVerticalBar;": { "codepoints": [8741], "characters": "\u2225" },
+  "&DownArrow;": { "codepoints": [8595], "characters": "\u2193" },
+  "&DownArrowBar;": { "codepoints": [10515], "characters": "\u2913" },
+  "&DownArrowUpArrow;": { "codepoints": [8693], "characters": "\u21F5" },
+  "&DownBreve;": { "codepoints": [785], "characters": "\u0311" },
+  "&DownLeftRightVector;": { "codepoints": [10576], "characters": "\u2950" },
+  "&DownLeftTeeVector;": { "codepoints": [10590], "characters": "\u295E" },
+  "&DownLeftVector;": { "codepoints": [8637], "characters": "\u21BD" },
+  "&DownLeftVectorBar;": { "codepoints": [10582], "characters": "\u2956" },
+  "&DownRightTeeVector;": { "codepoints": [10591], "characters": "\u295F" },
+  "&DownRightVector;": { "codepoints": [8641], "characters": "\u21C1" },
+  "&DownRightVectorBar;": { "codepoints": [10583], "characters": "\u2957" },
+  "&DownTee;": { "codepoints": [8868], "characters": "\u22A4" },
+  "&DownTeeArrow;": { "codepoints": [8615], "characters": "\u21A7" },
+  "&Downarrow;": { "codepoints": [8659], "characters": "\u21D3" },
+  "&Dscr;": { "codepoints": [119967], "characters": "\uD835\uDC9F" },
+  "&Dstrok;": { "codepoints": [272], "characters": "\u0110" },
+  "&ENG;": { "codepoints": [330], "characters": "\u014A" },
+  "&ETH": { "codepoints": [208], "characters": "\u00D0" },
+  "&ETH;": { "codepoints": [208], "characters": "\u00D0" },
+  "&Eacute": { "codepoints": [201], "characters": "\u00C9" },
+  "&Eacute;": { "codepoints": [201], "characters": "\u00C9" },
+  "&Ecaron;": { "codepoints": [282], "characters": "\u011A" },
+  "&Ecirc": { "codepoints": [202], "characters": "\u00CA" },
+  "&Ecirc;": { "codepoints": [202], "characters": "\u00CA" },
+  "&Ecy;": { "codepoints": [1069], "characters": "\u042D" },
+  "&Edot;": { "codepoints": [278], "characters": "\u0116" },
+  "&Efr;": { "codepoints": [120072], "characters": "\uD835\uDD08" },
+  "&Egrave": { "codepoints": [200], "characters": "\u00C8" },
+  "&Egrave;": { "codepoints": [200], "characters": "\u00C8" },
+  "&Element;": { "codepoints": [8712], "characters": "\u2208" },
+  "&Emacr;": { "codepoints": [274], "characters": "\u0112" },
+  "&EmptySmallSquare;": { "codepoints": [9723], "characters": "\u25FB" },
+  "&EmptyVerySmallSquare;": { "codepoints": [9643], "characters": "\u25AB" },
+  "&Eogon;": { "codepoints": [280], "characters": "\u0118" },
+  "&Eopf;": { "codepoints": [120124], "characters": "\uD835\uDD3C" },
+  "&Epsilon;": { "codepoints": [917], "characters": "\u0395" },
+  "&Equal;": { "codepoints": [10869], "characters": "\u2A75" },
+  "&EqualTilde;": { "codepoints": [8770], "characters": "\u2242" },
+  "&Equilibrium;": { "codepoints": [8652], "characters": "\u21CC" },
+  "&Escr;": { "codepoints": [8496], "characters": "\u2130" },
+  "&Esim;": { "codepoints": [10867], "characters": "\u2A73" },
+  "&Eta;": { "codepoints": [919], "characters": "\u0397" },
+  "&Euml": { "codepoints": [203], "characters": "\u00CB" },
+  "&Euml;": { "codepoints": [203], "characters": "\u00CB" },
+  "&Exists;": { "codepoints": [8707], "characters": "\u2203" },
+  "&ExponentialE;": { "codepoints": [8519], "characters": "\u2147" },
+  "&Fcy;": { "codepoints": [1060], "characters": "\u0424" },
+  "&Ffr;": { "codepoints": [120073], "characters": "\uD835\uDD09" },
+  "&FilledSmallSquare;": { "codepoints": [9724], "characters": "\u25FC" },
+  "&FilledVerySmallSquare;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&Fopf;": { "codepoints": [120125], "characters": "\uD835\uDD3D" },
+  "&ForAll;": { "codepoints": [8704], "characters": "\u2200" },
+  "&Fouriertrf;": { "codepoints": [8497], "characters": "\u2131" },
+  "&Fscr;": { "codepoints": [8497], "characters": "\u2131" },
+  "&GJcy;": { "codepoints": [1027], "characters": "\u0403" },
+  "&GT": { "codepoints": [62], "characters": "\u003E" },
+  "&GT;": { "codepoints": [62], "characters": "\u003E" },
+  "&Gamma;": { "codepoints": [915], "characters": "\u0393" },
+  "&Gammad;": { "codepoints": [988], "characters": "\u03DC" },
+  "&Gbreve;": { "codepoints": [286], "characters": "\u011E" },
+  "&Gcedil;": { "codepoints": [290], "characters": "\u0122" },
+  "&Gcirc;": { "codepoints": [284], "characters": "\u011C" },
+  "&Gcy;": { "codepoints": [1043], "characters": "\u0413" },
+  "&Gdot;": { "codepoints": [288], "characters": "\u0120" },
+  "&Gfr;": { "codepoints": [120074], "characters": "\uD835\uDD0A" },
+  "&Gg;": { "codepoints": [8921], "characters": "\u22D9" },
+  "&Gopf;": { "codepoints": [120126], "characters": "\uD835\uDD3E" },
+  "&GreaterEqual;": { "codepoints": [8805], "characters": "\u2265" },
+  "&GreaterEqualLess;": { "codepoints": [8923], "characters": "\u22DB" },
+  "&GreaterFullEqual;": { "codepoints": [8807], "characters": "\u2267" },
+  "&GreaterGreater;": { "codepoints": [10914], "characters": "\u2AA2" },
+  "&GreaterLess;": { "codepoints": [8823], "characters": "\u2277" },
+  "&GreaterSlantEqual;": { "codepoints": [10878], "characters": "\u2A7E" },
+  "&GreaterTilde;": { "codepoints": [8819], "characters": "\u2273" },
+  "&Gscr;": { "codepoints": [119970], "characters": "\uD835\uDCA2" },
+  "&Gt;": { "codepoints": [8811], "characters": "\u226B" },
+  "&HARDcy;": { "codepoints": [1066], "characters": "\u042A" },
+  "&Hacek;": { "codepoints": [711], "characters": "\u02C7" },
+  "&Hat;": { "codepoints": [94], "characters": "\u005E" },
+  "&Hcirc;": { "codepoints": [292], "characters": "\u0124" },
+  "&Hfr;": { "codepoints": [8460], "characters": "\u210C" },
+  "&HilbertSpace;": { "codepoints": [8459], "characters": "\u210B" },
+  "&Hopf;": { "codepoints": [8461], "characters": "\u210D" },
+  "&HorizontalLine;": { "codepoints": [9472], "characters": "\u2500" },
+  "&Hscr;": { "codepoints": [8459], "characters": "\u210B" },
+  "&Hstrok;": { "codepoints": [294], "characters": "\u0126" },
+  "&HumpDownHump;": { "codepoints": [8782], "characters": "\u224E" },
+  "&HumpEqual;": { "codepoints": [8783], "characters": "\u224F" },
+  "&IEcy;": { "codepoints": [1045], "characters": "\u0415" },
+  "&IJlig;": { "codepoints": [306], "characters": "\u0132" },
+  "&IOcy;": { "codepoints": [1025], "characters": "\u0401" },
+  "&Iacute": { "codepoints": [205], "characters": "\u00CD" },
+  "&Iacute;": { "codepoints": [205], "characters": "\u00CD" },
+  "&Icirc": { "codepoints": [206], "characters": "\u00CE" },
+  "&Icirc;": { "codepoints": [206], "characters": "\u00CE" },
+  "&Icy;": { "codepoints": [1048], "characters": "\u0418" },
+  "&Idot;": { "codepoints": [304], "characters": "\u0130" },
+  "&Ifr;": { "codepoints": [8465], "characters": "\u2111" },
+  "&Igrave": { "codepoints": [204], "characters": "\u00CC" },
+  "&Igrave;": { "codepoints": [204], "characters": "\u00CC" },
+  "&Im;": { "codepoints": [8465], "characters": "\u2111" },
+  "&Imacr;": { "codepoints": [298], "characters": "\u012A" },
+  "&ImaginaryI;": { "codepoints": [8520], "characters": "\u2148" },
+  "&Implies;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&Int;": { "codepoints": [8748], "characters": "\u222C" },
+  "&Integral;": { "codepoints": [8747], "characters": "\u222B" },
+  "&Intersection;": { "codepoints": [8898], "characters": "\u22C2" },
+  "&InvisibleComma;": { "codepoints": [8291], "characters": "\u2063" },
+  "&InvisibleTimes;": { "codepoints": [8290], "characters": "\u2062" },
+  "&Iogon;": { "codepoints": [302], "characters": "\u012E" },
+  "&Iopf;": { "codepoints": [120128], "characters": "\uD835\uDD40" },
+  "&Iota;": { "codepoints": [921], "characters": "\u0399" },
+  "&Iscr;": { "codepoints": [8464], "characters": "\u2110" },
+  "&Itilde;": { "codepoints": [296], "characters": "\u0128" },
+  "&Iukcy;": { "codepoints": [1030], "characters": "\u0406" },
+  "&Iuml": { "codepoints": [207], "characters": "\u00CF" },
+  "&Iuml;": { "codepoints": [207], "characters": "\u00CF" },
+  "&Jcirc;": { "codepoints": [308], "characters": "\u0134" },
+  "&Jcy;": { "codepoints": [1049], "characters": "\u0419" },
+  "&Jfr;": { "codepoints": [120077], "characters": "\uD835\uDD0D" },
+  "&Jopf;": { "codepoints": [120129], "characters": "\uD835\uDD41" },
+  "&Jscr;": { "codepoints": [119973], "characters": "\uD835\uDCA5" },
+  "&Jsercy;": { "codepoints": [1032], "characters": "\u0408" },
+  "&Jukcy;": { "codepoints": [1028], "characters": "\u0404" },
+  "&KHcy;": { "codepoints": [1061], "characters": "\u0425" },
+  "&KJcy;": { "codepoints": [1036], "characters": "\u040C" },
+  "&Kappa;": { "codepoints": [922], "characters": "\u039A" },
+  "&Kcedil;": { "codepoints": [310], "characters": "\u0136" },
+  "&Kcy;": { "codepoints": [1050], "characters": "\u041A" },
+  "&Kfr;": { "codepoints": [120078], "characters": "\uD835\uDD0E" },
+  "&Kopf;": { "codepoints": [120130], "characters": "\uD835\uDD42" },
+  "&Kscr;": { "codepoints": [119974], "characters": "\uD835\uDCA6" },
+  "&LJcy;": { "codepoints": [1033], "characters": "\u0409" },
+  "&LT": { "codepoints": [60], "characters": "\u003C" },
+  "&LT;": { "codepoints": [60], "characters": "\u003C" },
+  "&Lacute;": { "codepoints": [313], "characters": "\u0139" },
+  "&Lambda;": { "codepoints": [923], "characters": "\u039B" },
+  "&Lang;": { "codepoints": [10218], "characters": "\u27EA" },
+  "&Laplacetrf;": { "codepoints": [8466], "characters": "\u2112" },
+  "&Larr;": { "codepoints": [8606], "characters": "\u219E" },
+  "&Lcaron;": { "codepoints": [317], "characters": "\u013D" },
+  "&Lcedil;": { "codepoints": [315], "characters": "\u013B" },
+  "&Lcy;": { "codepoints": [1051], "characters": "\u041B" },
+  "&LeftAngleBracket;": { "codepoints": [10216], "characters": "\u27E8" },
+  "&LeftArrow;": { "codepoints": [8592], "characters": "\u2190" },
+  "&LeftArrowBar;": { "codepoints": [8676], "characters": "\u21E4" },
+  "&LeftArrowRightArrow;": { "codepoints": [8646], "characters": "\u21C6" },
+  "&LeftCeiling;": { "codepoints": [8968], "characters": "\u2308" },
+  "&LeftDoubleBracket;": { "codepoints": [10214], "characters": "\u27E6" },
+  "&LeftDownTeeVector;": { "codepoints": [10593], "characters": "\u2961" },
+  "&LeftDownVector;": { "codepoints": [8643], "characters": "\u21C3" },
+  "&LeftDownVectorBar;": { "codepoints": [10585], "characters": "\u2959" },
+  "&LeftFloor;": { "codepoints": [8970], "characters": "\u230A" },
+  "&LeftRightArrow;": { "codepoints": [8596], "characters": "\u2194" },
+  "&LeftRightVector;": { "codepoints": [10574], "characters": "\u294E" },
+  "&LeftTee;": { "codepoints": [8867], "characters": "\u22A3" },
+  "&LeftTeeArrow;": { "codepoints": [8612], "characters": "\u21A4" },
+  "&LeftTeeVector;": { "codepoints": [10586], "characters": "\u295A" },
+  "&LeftTriangle;": { "codepoints": [8882], "characters": "\u22B2" },
+  "&LeftTriangleBar;": { "codepoints": [10703], "characters": "\u29CF" },
+  "&LeftTriangleEqual;": { "codepoints": [8884], "characters": "\u22B4" },
+  "&LeftUpDownVector;": { "codepoints": [10577], "characters": "\u2951" },
+  "&LeftUpTeeVector;": { "codepoints": [10592], "characters": "\u2960" },
+  "&LeftUpVector;": { "codepoints": [8639], "characters": "\u21BF" },
+  "&LeftUpVectorBar;": { "codepoints": [10584], "characters": "\u2958" },
+  "&LeftVector;": { "codepoints": [8636], "characters": "\u21BC" },
+  "&LeftVectorBar;": { "codepoints": [10578], "characters": "\u2952" },
+  "&Leftarrow;": { "codepoints": [8656], "characters": "\u21D0" },
+  "&Leftrightarrow;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&LessEqualGreater;": { "codepoints": [8922], "characters": "\u22DA" },
+  "&LessFullEqual;": { "codepoints": [8806], "characters": "\u2266" },
+  "&LessGreater;": { "codepoints": [8822], "characters": "\u2276" },
+  "&LessLess;": { "codepoints": [10913], "characters": "\u2AA1" },
+  "&LessSlantEqual;": { "codepoints": [10877], "characters": "\u2A7D" },
+  "&LessTilde;": { "codepoints": [8818], "characters": "\u2272" },
+  "&Lfr;": { "codepoints": [120079], "characters": "\uD835\uDD0F" },
+  "&Ll;": { "codepoints": [8920], "characters": "\u22D8" },
+  "&Lleftarrow;": { "codepoints": [8666], "characters": "\u21DA" },
+  "&Lmidot;": { "codepoints": [319], "characters": "\u013F" },
+  "&LongLeftArrow;": { "codepoints": [10229], "characters": "\u27F5" },
+  "&LongLeftRightArrow;": { "codepoints": [10231], "characters": "\u27F7" },
+  "&LongRightArrow;": { "codepoints": [10230], "characters": "\u27F6" },
+  "&Longleftarrow;": { "codepoints": [10232], "characters": "\u27F8" },
+  "&Longleftrightarrow;": { "codepoints": [10234], "characters": "\u27FA" },
+  "&Longrightarrow;": { "codepoints": [10233], "characters": "\u27F9" },
+  "&Lopf;": { "codepoints": [120131], "characters": "\uD835\uDD43" },
+  "&LowerLeftArrow;": { "codepoints": [8601], "characters": "\u2199" },
+  "&LowerRightArrow;": { "codepoints": [8600], "characters": "\u2198" },
+  "&Lscr;": { "codepoints": [8466], "characters": "\u2112" },
+  "&Lsh;": { "codepoints": [8624], "characters": "\u21B0" },
+  "&Lstrok;": { "codepoints": [321], "characters": "\u0141" },
+  "&Lt;": { "codepoints": [8810], "characters": "\u226A" },
+  "&Map;": { "codepoints": [10501], "characters": "\u2905" },
+  "&Mcy;": { "codepoints": [1052], "characters": "\u041C" },
+  "&MediumSpace;": { "codepoints": [8287], "characters": "\u205F" },
+  "&Mellintrf;": { "codepoints": [8499], "characters": "\u2133" },
+  "&Mfr;": { "codepoints": [120080], "characters": "\uD835\uDD10" },
+  "&MinusPlus;": { "codepoints": [8723], "characters": "\u2213" },
+  "&Mopf;": { "codepoints": [120132], "characters": "\uD835\uDD44" },
+  "&Mscr;": { "codepoints": [8499], "characters": "\u2133" },
+  "&Mu;": { "codepoints": [924], "characters": "\u039C" },
+  "&NJcy;": { "codepoints": [1034], "characters": "\u040A" },
+  "&Nacute;": { "codepoints": [323], "characters": "\u0143" },
+  "&Ncaron;": { "codepoints": [327], "characters": "\u0147" },
+  "&Ncedil;": { "codepoints": [325], "characters": "\u0145" },
+  "&Ncy;": { "codepoints": [1053], "characters": "\u041D" },
+  "&NegativeMediumSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&NegativeThickSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&NegativeThinSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&NegativeVeryThinSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&NestedGreaterGreater;": { "codepoints": [8811], "characters": "\u226B" },
+  "&NestedLessLess;": { "codepoints": [8810], "characters": "\u226A" },
+  "&NewLine;": { "codepoints": [10], "characters": "\u000A" },
+  "&Nfr;": { "codepoints": [120081], "characters": "\uD835\uDD11" },
+  "&NoBreak;": { "codepoints": [8288], "characters": "\u2060" },
+  "&NonBreakingSpace;": { "codepoints": [160], "characters": "\u00A0" },
+  "&Nopf;": { "codepoints": [8469], "characters": "\u2115" },
+  "&Not;": { "codepoints": [10988], "characters": "\u2AEC" },
+  "&NotCongruent;": { "codepoints": [8802], "characters": "\u2262" },
+  "&NotCupCap;": { "codepoints": [8813], "characters": "\u226D" },
+  "&NotDoubleVerticalBar;": { "codepoints": [8742], "characters": "\u2226" },
+  "&NotElement;": { "codepoints": [8713], "characters": "\u2209" },
+  "&NotEqual;": { "codepoints": [8800], "characters": "\u2260" },
+  "&NotEqualTilde;": { "codepoints": [8770, 824], "characters": "\u2242\u0338" },
+  "&NotExists;": { "codepoints": [8708], "characters": "\u2204" },
+  "&NotGreater;": { "codepoints": [8815], "characters": "\u226F" },
+  "&NotGreaterEqual;": { "codepoints": [8817], "characters": "\u2271" },
+  "&NotGreaterFullEqual;": { "codepoints": [8807, 824], "characters": "\u2267\u0338" },
+  "&NotGreaterGreater;": { "codepoints": [8811, 824], "characters": "\u226B\u0338" },
+  "&NotGreaterLess;": { "codepoints": [8825], "characters": "\u2279" },
+  "&NotGreaterSlantEqual;": { "codepoints": [10878, 824], "characters": "\u2A7E\u0338" },
+  "&NotGreaterTilde;": { "codepoints": [8821], "characters": "\u2275" },
+  "&NotHumpDownHump;": { "codepoints": [8782, 824], "characters": "\u224E\u0338" },
+  "&NotHumpEqual;": { "codepoints": [8783, 824], "characters": "\u224F\u0338" },
+  "&NotLeftTriangle;": { "codepoints": [8938], "characters": "\u22EA" },
+  "&NotLeftTriangleBar;": { "codepoints": [10703, 824], "characters": "\u29CF\u0338" },
+  "&NotLeftTriangleEqual;": { "codepoints": [8940], "characters": "\u22EC" },
+  "&NotLess;": { "codepoints": [8814], "characters": "\u226E" },
+  "&NotLessEqual;": { "codepoints": [8816], "characters": "\u2270" },
+  "&NotLessGreater;": { "codepoints": [8824], "characters": "\u2278" },
+  "&NotLessLess;": { "codepoints": [8810, 824], "characters": "\u226A\u0338" },
+  "&NotLessSlantEqual;": { "codepoints": [10877, 824], "characters": "\u2A7D\u0338" },
+  "&NotLessTilde;": { "codepoints": [8820], "characters": "\u2274" },
+  "&NotNestedGreaterGreater;": { "codepoints": [10914, 824], "characters": "\u2AA2\u0338" },
+  "&NotNestedLessLess;": { "codepoints": [10913, 824], "characters": "\u2AA1\u0338" },
+  "&NotPrecedes;": { "codepoints": [8832], "characters": "\u2280" },
+  "&NotPrecedesEqual;": { "codepoints": [10927, 824], "characters": "\u2AAF\u0338" },
+  "&NotPrecedesSlantEqual;": { "codepoints": [8928], "characters": "\u22E0" },
+  "&NotReverseElement;": { "codepoints": [8716], "characters": "\u220C" },
+  "&NotRightTriangle;": { "codepoints": [8939], "characters": "\u22EB" },
+  "&NotRightTriangleBar;": { "codepoints": [10704, 824], "characters": "\u29D0\u0338" },
+  "&NotRightTriangleEqual;": { "codepoints": [8941], "characters": "\u22ED" },
+  "&NotSquareSubset;": { "codepoints": [8847, 824], "characters": "\u228F\u0338" },
+  "&NotSquareSubsetEqual;": { "codepoints": [8930], "characters": "\u22E2" },
+  "&NotSquareSuperset;": { "codepoints": [8848, 824], "characters": "\u2290\u0338" },
+  "&NotSquareSupersetEqual;": { "codepoints": [8931], "characters": "\u22E3" },
+  "&NotSubset;": { "codepoints": [8834, 8402], "characters": "\u2282\u20D2" },
+  "&NotSubsetEqual;": { "codepoints": [8840], "characters": "\u2288" },
+  "&NotSucceeds;": { "codepoints": [8833], "characters": "\u2281" },
+  "&NotSucceedsEqual;": { "codepoints": [10928, 824], "characters": "\u2AB0\u0338" },
+  "&NotSucceedsSlantEqual;": { "codepoints": [8929], "characters": "\u22E1" },
+  "&NotSucceedsTilde;": { "codepoints": [8831, 824], "characters": "\u227F\u0338" },
+  "&NotSuperset;": { "codepoints": [8835, 8402], "characters": "\u2283\u20D2" },
+  "&NotSupersetEqual;": { "codepoints": [8841], "characters": "\u2289" },
+  "&NotTilde;": { "codepoints": [8769], "characters": "\u2241" },
+  "&NotTildeEqual;": { "codepoints": [8772], "characters": "\u2244" },
+  "&NotTildeFullEqual;": { "codepoints": [8775], "characters": "\u2247" },
+  "&NotTildeTilde;": { "codepoints": [8777], "characters": "\u2249" },
+  "&NotVerticalBar;": { "codepoints": [8740], "characters": "\u2224" },
+  "&Nscr;": { "codepoints": [119977], "characters": "\uD835\uDCA9" },
+  "&Ntilde": { "codepoints": [209], "characters": "\u00D1" },
+  "&Ntilde;": { "codepoints": [209], "characters": "\u00D1" },
+  "&Nu;": { "codepoints": [925], "characters": "\u039D" },
+  "&OElig;": { "codepoints": [338], "characters": "\u0152" },
+  "&Oacute": { "codepoints": [211], "characters": "\u00D3" },
+  "&Oacute;": { "codepoints": [211], "characters": "\u00D3" },
+  "&Ocirc": { "codepoints": [212], "characters": "\u00D4" },
+  "&Ocirc;": { "codepoints": [212], "characters": "\u00D4" },
+  "&Ocy;": { "codepoints": [1054], "characters": "\u041E" },
+  "&Odblac;": { "codepoints": [336], "characters": "\u0150" },
+  "&Ofr;": { "codepoints": [120082], "characters": "\uD835\uDD12" },
+  "&Ograve": { "codepoints": [210], "characters": "\u00D2" },
+  "&Ograve;": { "codepoints": [210], "characters": "\u00D2" },
+  "&Omacr;": { "codepoints": [332], "characters": "\u014C" },
+  "&Omega;": { "codepoints": [937], "characters": "\u03A9" },
+  "&Omicron;": { "codepoints": [927], "characters": "\u039F" },
+  "&Oopf;": { "codepoints": [120134], "characters": "\uD835\uDD46" },
+  "&OpenCurlyDoubleQuote;": { "codepoints": [8220], "characters": "\u201C" },
+  "&OpenCurlyQuote;": { "codepoints": [8216], "characters": "\u2018" },
+  "&Or;": { "codepoints": [10836], "characters": "\u2A54" },
+  "&Oscr;": { "codepoints": [119978], "characters": "\uD835\uDCAA" },
+  "&Oslash": { "codepoints": [216], "characters": "\u00D8" },
+  "&Oslash;": { "codepoints": [216], "characters": "\u00D8" },
+  "&Otilde": { "codepoints": [213], "characters": "\u00D5" },
+  "&Otilde;": { "codepoints": [213], "characters": "\u00D5" },
+  "&Otimes;": { "codepoints": [10807], "characters": "\u2A37" },
+  "&Ouml": { "codepoints": [214], "characters": "\u00D6" },
+  "&Ouml;": { "codepoints": [214], "characters": "\u00D6" },
+  "&OverBar;": { "codepoints": [8254], "characters": "\u203E" },
+  "&OverBrace;": { "codepoints": [9182], "characters": "\u23DE" },
+  "&OverBracket;": { "codepoints": [9140], "characters": "\u23B4" },
+  "&OverParenthesis;": { "codepoints": [9180], "characters": "\u23DC" },
+  "&PartialD;": { "codepoints": [8706], "characters": "\u2202" },
+  "&Pcy;": { "codepoints": [1055], "characters": "\u041F" },
+  "&Pfr;": { "codepoints": [120083], "characters": "\uD835\uDD13" },
+  "&Phi;": { "codepoints": [934], "characters": "\u03A6" },
+  "&Pi;": { "codepoints": [928], "characters": "\u03A0" },
+  "&PlusMinus;": { "codepoints": [177], "characters": "\u00B1" },
+  "&Poincareplane;": { "codepoints": [8460], "characters": "\u210C" },
+  "&Popf;": { "codepoints": [8473], "characters": "\u2119" },
+  "&Pr;": { "codepoints": [10939], "characters": "\u2ABB" },
+  "&Precedes;": { "codepoints": [8826], "characters": "\u227A" },
+  "&PrecedesEqual;": { "codepoints": [10927], "characters": "\u2AAF" },
+  "&PrecedesSlantEqual;": { "codepoints": [8828], "characters": "\u227C" },
+  "&PrecedesTilde;": { "codepoints": [8830], "characters": "\u227E" },
+  "&Prime;": { "codepoints": [8243], "characters": "\u2033" },
+  "&Product;": { "codepoints": [8719], "characters": "\u220F" },
+  "&Proportion;": { "codepoints": [8759], "characters": "\u2237" },
+  "&Proportional;": { "codepoints": [8733], "characters": "\u221D" },
+  "&Pscr;": { "codepoints": [119979], "characters": "\uD835\uDCAB" },
+  "&Psi;": { "codepoints": [936], "characters": "\u03A8" },
+  "&QUOT": { "codepoints": [34], "characters": "\u0022" },
+  "&QUOT;": { "codepoints": [34], "characters": "\u0022" },
+  "&Qfr;": { "codepoints": [120084], "characters": "\uD835\uDD14" },
+  "&Qopf;": { "codepoints": [8474], "characters": "\u211A" },
+  "&Qscr;": { "codepoints": [119980], "characters": "\uD835\uDCAC" },
+  "&RBarr;": { "codepoints": [10512], "characters": "\u2910" },
+  "&REG": { "codepoints": [174], "characters": "\u00AE" },
+  "&REG;": { "codepoints": [174], "characters": "\u00AE" },
+  "&Racute;": { "codepoints": [340], "characters": "\u0154" },
+  "&Rang;": { "codepoints": [10219], "characters": "\u27EB" },
+  "&Rarr;": { "codepoints": [8608], "characters": "\u21A0" },
+  "&Rarrtl;": { "codepoints": [10518], "characters": "\u2916" },
+  "&Rcaron;": { "codepoints": [344], "characters": "\u0158" },
+  "&Rcedil;": { "codepoints": [342], "characters": "\u0156" },
+  "&Rcy;": { "codepoints": [1056], "characters": "\u0420" },
+  "&Re;": { "codepoints": [8476], "characters": "\u211C" },
+  "&ReverseElement;": { "codepoints": [8715], "characters": "\u220B" },
+  "&ReverseEquilibrium;": { "codepoints": [8651], "characters": "\u21CB" },
+  "&ReverseUpEquilibrium;": { "codepoints": [10607], "characters": "\u296F" },
+  "&Rfr;": { "codepoints": [8476], "characters": "\u211C" },
+  "&Rho;": { "codepoints": [929], "characters": "\u03A1" },
+  "&RightAngleBracket;": { "codepoints": [10217], "characters": "\u27E9" },
+  "&RightArrow;": { "codepoints": [8594], "characters": "\u2192" },
+  "&RightArrowBar;": { "codepoints": [8677], "characters": "\u21E5" },
+  "&RightArrowLeftArrow;": { "codepoints": [8644], "characters": "\u21C4" },
+  "&RightCeiling;": { "codepoints": [8969], "characters": "\u2309" },
+  "&RightDoubleBracket;": { "codepoints": [10215], "characters": "\u27E7" },
+  "&RightDownTeeVector;": { "codepoints": [10589], "characters": "\u295D" },
+  "&RightDownVector;": { "codepoints": [8642], "characters": "\u21C2" },
+  "&RightDownVectorBar;": { "codepoints": [10581], "characters": "\u2955" },
+  "&RightFloor;": { "codepoints": [8971], "characters": "\u230B" },
+  "&RightTee;": { "codepoints": [8866], "characters": "\u22A2" },
+  "&RightTeeArrow;": { "codepoints": [8614], "characters": "\u21A6" },
+  "&RightTeeVector;": { "codepoints": [10587], "characters": "\u295B" },
+  "&RightTriangle;": { "codepoints": [8883], "characters": "\u22B3" },
+  "&RightTriangleBar;": { "codepoints": [10704], "characters": "\u29D0" },
+  "&RightTriangleEqual;": { "codepoints": [8885], "characters": "\u22B5" },
+  "&RightUpDownVector;": { "codepoints": [10575], "characters": "\u294F" },
+  "&RightUpTeeVector;": { "codepoints": [10588], "characters": "\u295C" },
+  "&RightUpVector;": { "codepoints": [8638], "characters": "\u21BE" },
+  "&RightUpVectorBar;": { "codepoints": [10580], "characters": "\u2954" },
+  "&RightVector;": { "codepoints": [8640], "characters": "\u21C0" },
+  "&RightVectorBar;": { "codepoints": [10579], "characters": "\u2953" },
+  "&Rightarrow;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&Ropf;": { "codepoints": [8477], "characters": "\u211D" },
+  "&RoundImplies;": { "codepoints": [10608], "characters": "\u2970" },
+  "&Rrightarrow;": { "codepoints": [8667], "characters": "\u21DB" },
+  "&Rscr;": { "codepoints": [8475], "characters": "\u211B" },
+  "&Rsh;": { "codepoints": [8625], "characters": "\u21B1" },
+  "&RuleDelayed;": { "codepoints": [10740], "characters": "\u29F4" },
+  "&SHCHcy;": { "codepoints": [1065], "characters": "\u0429" },
+  "&SHcy;": { "codepoints": [1064], "characters": "\u0428" },
+  "&SOFTcy;": { "codepoints": [1068], "characters": "\u042C" },
+  "&Sacute;": { "codepoints": [346], "characters": "\u015A" },
+  "&Sc;": { "codepoints": [10940], "characters": "\u2ABC" },
+  "&Scaron;": { "codepoints": [352], "characters": "\u0160" },
+  "&Scedil;": { "codepoints": [350], "characters": "\u015E" },
+  "&Scirc;": { "codepoints": [348], "characters": "\u015C" },
+  "&Scy;": { "codepoints": [1057], "characters": "\u0421" },
+  "&Sfr;": { "codepoints": [120086], "characters": "\uD835\uDD16" },
+  "&ShortDownArrow;": { "codepoints": [8595], "characters": "\u2193" },
+  "&ShortLeftArrow;": { "codepoints": [8592], "characters": "\u2190" },
+  "&ShortRightArrow;": { "codepoints": [8594], "characters": "\u2192" },
+  "&ShortUpArrow;": { "codepoints": [8593], "characters": "\u2191" },
+  "&Sigma;": { "codepoints": [931], "characters": "\u03A3" },
+  "&SmallCircle;": { "codepoints": [8728], "characters": "\u2218" },
+  "&Sopf;": { "codepoints": [120138], "characters": "\uD835\uDD4A" },
+  "&Sqrt;": { "codepoints": [8730], "characters": "\u221A" },
+  "&Square;": { "codepoints": [9633], "characters": "\u25A1" },
+  "&SquareIntersection;": { "codepoints": [8851], "characters": "\u2293" },
+  "&SquareSubset;": { "codepoints": [8847], "characters": "\u228F" },
+  "&SquareSubsetEqual;": { "codepoints": [8849], "characters": "\u2291" },
+  "&SquareSuperset;": { "codepoints": [8848], "characters": "\u2290" },
+  "&SquareSupersetEqual;": { "codepoints": [8850], "characters": "\u2292" },
+  "&SquareUnion;": { "codepoints": [8852], "characters": "\u2294" },
+  "&Sscr;": { "codepoints": [119982], "characters": "\uD835\uDCAE" },
+  "&Star;": { "codepoints": [8902], "characters": "\u22C6" },
+  "&Sub;": { "codepoints": [8912], "characters": "\u22D0" },
+  "&Subset;": { "codepoints": [8912], "characters": "\u22D0" },
+  "&SubsetEqual;": { "codepoints": [8838], "characters": "\u2286" },
+  "&Succeeds;": { "codepoints": [8827], "characters": "\u227B" },
+  "&SucceedsEqual;": { "codepoints": [10928], "characters": "\u2AB0" },
+  "&SucceedsSlantEqual;": { "codepoints": [8829], "characters": "\u227D" },
+  "&SucceedsTilde;": { "codepoints": [8831], "characters": "\u227F" },
+  "&SuchThat;": { "codepoints": [8715], "characters": "\u220B" },
+  "&Sum;": { "codepoints": [8721], "characters": "\u2211" },
+  "&Sup;": { "codepoints": [8913], "characters": "\u22D1" },
+  "&Superset;": { "codepoints": [8835], "characters": "\u2283" },
+  "&SupersetEqual;": { "codepoints": [8839], "characters": "\u2287" },
+  "&Supset;": { "codepoints": [8913], "characters": "\u22D1" },
+  "&THORN": { "codepoints": [222], "characters": "\u00DE" },
+  "&THORN;": { "codepoints": [222], "characters": "\u00DE" },
+  "&TRADE;": { "codepoints": [8482], "characters": "\u2122" },
+  "&TSHcy;": { "codepoints": [1035], "characters": "\u040B" },
+  "&TScy;": { "codepoints": [1062], "characters": "\u0426" },
+  "&Tab;": { "codepoints": [9], "characters": "\u0009" },
+  "&Tau;": { "codepoints": [932], "characters": "\u03A4" },
+  "&Tcaron;": { "codepoints": [356], "characters": "\u0164" },
+  "&Tcedil;": { "codepoints": [354], "characters": "\u0162" },
+  "&Tcy;": { "codepoints": [1058], "characters": "\u0422" },
+  "&Tfr;": { "codepoints": [120087], "characters": "\uD835\uDD17" },
+  "&Therefore;": { "codepoints": [8756], "characters": "\u2234" },
+  "&Theta;": { "codepoints": [920], "characters": "\u0398" },
+  "&ThickSpace;": { "codepoints": [8287, 8202], "characters": "\u205F\u200A" },
+  "&ThinSpace;": { "codepoints": [8201], "characters": "\u2009" },
+  "&Tilde;": { "codepoints": [8764], "characters": "\u223C" },
+  "&TildeEqual;": { "codepoints": [8771], "characters": "\u2243" },
+  "&TildeFullEqual;": { "codepoints": [8773], "characters": "\u2245" },
+  "&TildeTilde;": { "codepoints": [8776], "characters": "\u2248" },
+  "&Topf;": { "codepoints": [120139], "characters": "\uD835\uDD4B" },
+  "&TripleDot;": { "codepoints": [8411], "characters": "\u20DB" },
+  "&Tscr;": { "codepoints": [119983], "characters": "\uD835\uDCAF" },
+  "&Tstrok;": { "codepoints": [358], "characters": "\u0166" },
+  "&Uacute": { "codepoints": [218], "characters": "\u00DA" },
+  "&Uacute;": { "codepoints": [218], "characters": "\u00DA" },
+  "&Uarr;": { "codepoints": [8607], "characters": "\u219F" },
+  "&Uarrocir;": { "codepoints": [10569], "characters": "\u2949" },
+  "&Ubrcy;": { "codepoints": [1038], "characters": "\u040E" },
+  "&Ubreve;": { "codepoints": [364], "characters": "\u016C" },
+  "&Ucirc": { "codepoints": [219], "characters": "\u00DB" },
+  "&Ucirc;": { "codepoints": [219], "characters": "\u00DB" },
+  "&Ucy;": { "codepoints": [1059], "characters": "\u0423" },
+  "&Udblac;": { "codepoints": [368], "characters": "\u0170" },
+  "&Ufr;": { "codepoints": [120088], "characters": "\uD835\uDD18" },
+  "&Ugrave": { "codepoints": [217], "characters": "\u00D9" },
+  "&Ugrave;": { "codepoints": [217], "characters": "\u00D9" },
+  "&Umacr;": { "codepoints": [362], "characters": "\u016A" },
+  "&UnderBar;": { "codepoints": [95], "characters": "\u005F" },
+  "&UnderBrace;": { "codepoints": [9183], "characters": "\u23DF" },
+  "&UnderBracket;": { "codepoints": [9141], "characters": "\u23B5" },
+  "&UnderParenthesis;": { "codepoints": [9181], "characters": "\u23DD" },
+  "&Union;": { "codepoints": [8899], "characters": "\u22C3" },
+  "&UnionPlus;": { "codepoints": [8846], "characters": "\u228E" },
+  "&Uogon;": { "codepoints": [370], "characters": "\u0172" },
+  "&Uopf;": { "codepoints": [120140], "characters": "\uD835\uDD4C" },
+  "&UpArrow;": { "codepoints": [8593], "characters": "\u2191" },
+  "&UpArrowBar;": { "codepoints": [10514], "characters": "\u2912" },
+  "&UpArrowDownArrow;": { "codepoints": [8645], "characters": "\u21C5" },
+  "&UpDownArrow;": { "codepoints": [8597], "characters": "\u2195" },
+  "&UpEquilibrium;": { "codepoints": [10606], "characters": "\u296E" },
+  "&UpTee;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&UpTeeArrow;": { "codepoints": [8613], "characters": "\u21A5" },
+  "&Uparrow;": { "codepoints": [8657], "characters": "\u21D1" },
+  "&Updownarrow;": { "codepoints": [8661], "characters": "\u21D5" },
+  "&UpperLeftArrow;": { "codepoints": [8598], "characters": "\u2196" },
+  "&UpperRightArrow;": { "codepoints": [8599], "characters": "\u2197" },
+  "&Upsi;": { "codepoints": [978], "characters": "\u03D2" },
+  "&Upsilon;": { "codepoints": [933], "characters": "\u03A5" },
+  "&Uring;": { "codepoints": [366], "characters": "\u016E" },
+  "&Uscr;": { "codepoints": [119984], "characters": "\uD835\uDCB0" },
+  "&Utilde;": { "codepoints": [360], "characters": "\u0168" },
+  "&Uuml": { "codepoints": [220], "characters": "\u00DC" },
+  "&Uuml;": { "codepoints": [220], "characters": "\u00DC" },
+  "&VDash;": { "codepoints": [8875], "characters": "\u22AB" },
+  "&Vbar;": { "codepoints": [10987], "characters": "\u2AEB" },
+  "&Vcy;": { "codepoints": [1042], "characters": "\u0412" },
+  "&Vdash;": { "codepoints": [8873], "characters": "\u22A9" },
+  "&Vdashl;": { "codepoints": [10982], "characters": "\u2AE6" },
+  "&Vee;": { "codepoints": [8897], "characters": "\u22C1" },
+  "&Verbar;": { "codepoints": [8214], "characters": "\u2016" },
+  "&Vert;": { "codepoints": [8214], "characters": "\u2016" },
+  "&VerticalBar;": { "codepoints": [8739], "characters": "\u2223" },
+  "&VerticalLine;": { "codepoints": [124], "characters": "\u007C" },
+  "&VerticalSeparator;": { "codepoints": [10072], "characters": "\u2758" },
+  "&VerticalTilde;": { "codepoints": [8768], "characters": "\u2240" },
+  "&VeryThinSpace;": { "codepoints": [8202], "characters": "\u200A" },
+  "&Vfr;": { "codepoints": [120089], "characters": "\uD835\uDD19" },
+  "&Vopf;": { "codepoints": [120141], "characters": "\uD835\uDD4D" },
+  "&Vscr;": { "codepoints": [119985], "characters": "\uD835\uDCB1" },
+  "&Vvdash;": { "codepoints": [8874], "characters": "\u22AA" },
+  "&Wcirc;": { "codepoints": [372], "characters": "\u0174" },
+  "&Wedge;": { "codepoints": [8896], "characters": "\u22C0" },
+  "&Wfr;": { "codepoints": [120090], "characters": "\uD835\uDD1A" },
+  "&Wopf;": { "codepoints": [120142], "characters": "\uD835\uDD4E" },
+  "&Wscr;": { "codepoints": [119986], "characters": "\uD835\uDCB2" },
+  "&Xfr;": { "codepoints": [120091], "characters": "\uD835\uDD1B" },
+  "&Xi;": { "codepoints": [926], "characters": "\u039E" },
+  "&Xopf;": { "codepoints": [120143], "characters": "\uD835\uDD4F" },
+  "&Xscr;": { "codepoints": [119987], "characters": "\uD835\uDCB3" },
+  "&YAcy;": { "codepoints": [1071], "characters": "\u042F" },
+  "&YIcy;": { "codepoints": [1031], "characters": "\u0407" },
+  "&YUcy;": { "codepoints": [1070], "characters": "\u042E" },
+  "&Yacute": { "codepoints": [221], "characters": "\u00DD" },
+  "&Yacute;": { "codepoints": [221], "characters": "\u00DD" },
+  "&Ycirc;": { "codepoints": [374], "characters": "\u0176" },
+  "&Ycy;": { "codepoints": [1067], "characters": "\u042B" },
+  "&Yfr;": { "codepoints": [120092], "characters": "\uD835\uDD1C" },
+  "&Yopf;": { "codepoints": [120144], "characters": "\uD835\uDD50" },
+  "&Yscr;": { "codepoints": [119988], "characters": "\uD835\uDCB4" },
+  "&Yuml;": { "codepoints": [376], "characters": "\u0178" },
+  "&ZHcy;": { "codepoints": [1046], "characters": "\u0416" },
+  "&Zacute;": { "codepoints": [377], "characters": "\u0179" },
+  "&Zcaron;": { "codepoints": [381], "characters": "\u017D" },
+  "&Zcy;": { "codepoints": [1047], "characters": "\u0417" },
+  "&Zdot;": { "codepoints": [379], "characters": "\u017B" },
+  "&ZeroWidthSpace;": { "codepoints": [8203], "characters": "\u200B" },
+  "&Zeta;": { "codepoints": [918], "characters": "\u0396" },
+  "&Zfr;": { "codepoints": [8488], "characters": "\u2128" },
+  "&Zopf;": { "codepoints": [8484], "characters": "\u2124" },
+  "&Zscr;": { "codepoints": [119989], "characters": "\uD835\uDCB5" },
+  "&aacute": { "codepoints": [225], "characters": "\u00E1" },
+  "&aacute;": { "codepoints": [225], "characters": "\u00E1" },
+  "&abreve;": { "codepoints": [259], "characters": "\u0103" },
+  "&ac;": { "codepoints": [8766], "characters": "\u223E" },
+  "&acE;": { "codepoints": [8766, 819], "characters": "\u223E\u0333" },
+  "&acd;": { "codepoints": [8767], "characters": "\u223F" },
+  "&acirc": { "codepoints": [226], "characters": "\u00E2" },
+  "&acirc;": { "codepoints": [226], "characters": "\u00E2" },
+  "&acute": { "codepoints": [180], "characters": "\u00B4" },
+  "&acute;": { "codepoints": [180], "characters": "\u00B4" },
+  "&acy;": { "codepoints": [1072], "characters": "\u0430" },
+  "&aelig": { "codepoints": [230], "characters": "\u00E6" },
+  "&aelig;": { "codepoints": [230], "characters": "\u00E6" },
+  "&af;": { "codepoints": [8289], "characters": "\u2061" },
+  "&afr;": { "codepoints": [120094], "characters": "\uD835\uDD1E" },
+  "&agrave": { "codepoints": [224], "characters": "\u00E0" },
+  "&agrave;": { "codepoints": [224], "characters": "\u00E0" },
+  "&alefsym;": { "codepoints": [8501], "characters": "\u2135" },
+  "&aleph;": { "codepoints": [8501], "characters": "\u2135" },
+  "&alpha;": { "codepoints": [945], "characters": "\u03B1" },
+  "&amacr;": { "codepoints": [257], "characters": "\u0101" },
+  "&amalg;": { "codepoints": [10815], "characters": "\u2A3F" },
+  "&amp": { "codepoints": [38], "characters": "\u0026" },
+  "&amp;": { "codepoints": [38], "characters": "\u0026" },
+  "&and;": { "codepoints": [8743], "characters": "\u2227" },
+  "&andand;": { "codepoints": [10837], "characters": "\u2A55" },
+  "&andd;": { "codepoints": [10844], "characters": "\u2A5C" },
+  "&andslope;": { "codepoints": [10840], "characters": "\u2A58" },
+  "&andv;": { "codepoints": [10842], "characters": "\u2A5A" },
+  "&ang;": { "codepoints": [8736], "characters": "\u2220" },
+  "&ange;": { "codepoints": [10660], "characters": "\u29A4" },
+  "&angle;": { "codepoints": [8736], "characters": "\u2220" },
+  "&angmsd;": { "codepoints": [8737], "characters": "\u2221" },
+  "&angmsdaa;": { "codepoints": [10664], "characters": "\u29A8" },
+  "&angmsdab;": { "codepoints": [10665], "characters": "\u29A9" },
+  "&angmsdac;": { "codepoints": [10666], "characters": "\u29AA" },
+  "&angmsdad;": { "codepoints": [10667], "characters": "\u29AB" },
+  "&angmsdae;": { "codepoints": [10668], "characters": "\u29AC" },
+  "&angmsdaf;": { "codepoints": [10669], "characters": "\u29AD" },
+  "&angmsdag;": { "codepoints": [10670], "characters": "\u29AE" },
+  "&angmsdah;": { "codepoints": [10671], "characters": "\u29AF" },
+  "&angrt;": { "codepoints": [8735], "characters": "\u221F" },
+  "&angrtvb;": { "codepoints": [8894], "characters": "\u22BE" },
+  "&angrtvbd;": { "codepoints": [10653], "characters": "\u299D" },
+  "&angsph;": { "codepoints": [8738], "characters": "\u2222" },
+  "&angst;": { "codepoints": [197], "characters": "\u00C5" },
+  "&angzarr;": { "codepoints": [9084], "characters": "\u237C" },
+  "&aogon;": { "codepoints": [261], "characters": "\u0105" },
+  "&aopf;": { "codepoints": [120146], "characters": "\uD835\uDD52" },
+  "&ap;": { "codepoints": [8776], "characters": "\u2248" },
+  "&apE;": { "codepoints": [10864], "characters": "\u2A70" },
+  "&apacir;": { "codepoints": [10863], "characters": "\u2A6F" },
+  "&ape;": { "codepoints": [8778], "characters": "\u224A" },
+  "&apid;": { "codepoints": [8779], "characters": "\u224B" },
+  "&apos;": { "codepoints": [39], "characters": "\u0027" },
+  "&approx;": { "codepoints": [8776], "characters": "\u2248" },
+  "&approxeq;": { "codepoints": [8778], "characters": "\u224A" },
+  "&aring": { "codepoints": [229], "characters": "\u00E5" },
+  "&aring;": { "codepoints": [229], "characters": "\u00E5" },
+  "&ascr;": { "codepoints": [119990], "characters": "\uD835\uDCB6" },
+  "&ast;": { "codepoints": [42], "characters": "\u002A" },
+  "&asymp;": { "codepoints": [8776], "characters": "\u2248" },
+  "&asympeq;": { "codepoints": [8781], "characters": "\u224D" },
+  "&atilde": { "codepoints": [227], "characters": "\u00E3" },
+  "&atilde;": { "codepoints": [227], "characters": "\u00E3" },
+  "&auml": { "codepoints": [228], "characters": "\u00E4" },
+  "&auml;": { "codepoints": [228], "characters": "\u00E4" },
+  "&awconint;": { "codepoints": [8755], "characters": "\u2233" },
+  "&awint;": { "codepoints": [10769], "characters": "\u2A11" },
+  "&bNot;": { "codepoints": [10989], "characters": "\u2AED" },
+  "&backcong;": { "codepoints": [8780], "characters": "\u224C" },
+  "&backepsilon;": { "codepoints": [1014], "characters": "\u03F6" },
+  "&backprime;": { "codepoints": [8245], "characters": "\u2035" },
+  "&backsim;": { "codepoints": [8765], "characters": "\u223D" },
+  "&backsimeq;": { "codepoints": [8909], "characters": "\u22CD" },
+  "&barvee;": { "codepoints": [8893], "characters": "\u22BD" },
+  "&barwed;": { "codepoints": [8965], "characters": "\u2305" },
+  "&barwedge;": { "codepoints": [8965], "characters": "\u2305" },
+  "&bbrk;": { "codepoints": [9141], "characters": "\u23B5" },
+  "&bbrktbrk;": { "codepoints": [9142], "characters": "\u23B6" },
+  "&bcong;": { "codepoints": [8780], "characters": "\u224C" },
+  "&bcy;": { "codepoints": [1073], "characters": "\u0431" },
+  "&bdquo;": { "codepoints": [8222], "characters": "\u201E" },
+  "&becaus;": { "codepoints": [8757], "characters": "\u2235" },
+  "&because;": { "codepoints": [8757], "characters": "\u2235" },
+  "&bemptyv;": { "codepoints": [10672], "characters": "\u29B0" },
+  "&bepsi;": { "codepoints": [1014], "characters": "\u03F6" },
+  "&bernou;": { "codepoints": [8492], "characters": "\u212C" },
+  "&beta;": { "codepoints": [946], "characters": "\u03B2" },
+  "&beth;": { "codepoints": [8502], "characters": "\u2136" },
+  "&between;": { "codepoints": [8812], "characters": "\u226C" },
+  "&bfr;": { "codepoints": [120095], "characters": "\uD835\uDD1F" },
+  "&bigcap;": { "codepoints": [8898], "characters": "\u22C2" },
+  "&bigcirc;": { "codepoints": [9711], "characters": "\u25EF" },
+  "&bigcup;": { "codepoints": [8899], "characters": "\u22C3" },
+  "&bigodot;": { "codepoints": [10752], "characters": "\u2A00" },
+  "&bigoplus;": { "codepoints": [10753], "characters": "\u2A01" },
+  "&bigotimes;": { "codepoints": [10754], "characters": "\u2A02" },
+  "&bigsqcup;": { "codepoints": [10758], "characters": "\u2A06" },
+  "&bigstar;": { "codepoints": [9733], "characters": "\u2605" },
+  "&bigtriangledown;": { "codepoints": [9661], "characters": "\u25BD" },
+  "&bigtriangleup;": { "codepoints": [9651], "characters": "\u25B3" },
+  "&biguplus;": { "codepoints": [10756], "characters": "\u2A04" },
+  "&bigvee;": { "codepoints": [8897], "characters": "\u22C1" },
+  "&bigwedge;": { "codepoints": [8896], "characters": "\u22C0" },
+  "&bkarow;": { "codepoints": [10509], "characters": "\u290D" },
+  "&blacklozenge;": { "codepoints": [10731], "characters": "\u29EB" },
+  "&blacksquare;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&blacktriangle;": { "codepoints": [9652], "characters": "\u25B4" },
+  "&blacktriangledown;": { "codepoints": [9662], "characters": "\u25BE" },
+  "&blacktriangleleft;": { "codepoints": [9666], "characters": "\u25C2" },
+  "&blacktriangleright;": { "codepoints": [9656], "characters": "\u25B8" },
+  "&blank;": { "codepoints": [9251], "characters": "\u2423" },
+  "&blk12;": { "codepoints": [9618], "characters": "\u2592" },
+  "&blk14;": { "codepoints": [9617], "characters": "\u2591" },
+  "&blk34;": { "codepoints": [9619], "characters": "\u2593" },
+  "&block;": { "codepoints": [9608], "characters": "\u2588" },
+  "&bne;": { "codepoints": [61, 8421], "characters": "\u003D\u20E5" },
+  "&bnequiv;": { "codepoints": [8801, 8421], "characters": "\u2261\u20E5" },
+  "&bnot;": { "codepoints": [8976], "characters": "\u2310" },
+  "&bopf;": { "codepoints": [120147], "characters": "\uD835\uDD53" },
+  "&bot;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&bottom;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&bowtie;": { "codepoints": [8904], "characters": "\u22C8" },
+  "&boxDL;": { "codepoints": [9559], "characters": "\u2557" },
+  "&boxDR;": { "codepoints": [9556], "characters": "\u2554" },
+  "&boxDl;": { "codepoints": [9558], "characters": "\u2556" },
+  "&boxDr;": { "codepoints": [9555], "characters": "\u2553" },
+  "&boxH;": { "codepoints": [9552], "characters": "\u2550" },
+  "&boxHD;": { "codepoints": [9574], "characters": "\u2566" },
+  "&boxHU;": { "codepoints": [9577], "characters": "\u2569" },
+  "&boxHd;": { "codepoints": [9572], "characters": "\u2564" },
+  "&boxHu;": { "codepoints": [9575], "characters": "\u2567" },
+  "&boxUL;": { "codepoints": [9565], "characters": "\u255D" },
+  "&boxUR;": { "codepoints": [9562], "characters": "\u255A" },
+  "&boxUl;": { "codepoints": [9564], "characters": "\u255C" },
+  "&boxUr;": { "codepoints": [9561], "characters": "\u2559" },
+  "&boxV;": { "codepoints": [9553], "characters": "\u2551" },
+  "&boxVH;": { "codepoints": [9580], "characters": "\u256C" },
+  "&boxVL;": { "codepoints": [9571], "characters": "\u2563" },
+  "&boxVR;": { "codepoints": [9568], "characters": "\u2560" },
+  "&boxVh;": { "codepoints": [9579], "characters": "\u256B" },
+  "&boxVl;": { "codepoints": [9570], "characters": "\u2562" },
+  "&boxVr;": { "codepoints": [9567], "characters": "\u255F" },
+  "&boxbox;": { "codepoints": [10697], "characters": "\u29C9" },
+  "&boxdL;": { "codepoints": [9557], "characters": "\u2555" },
+  "&boxdR;": { "codepoints": [9554], "characters": "\u2552" },
+  "&boxdl;": { "codepoints": [9488], "characters": "\u2510" },
+  "&boxdr;": { "codepoints": [9484], "characters": "\u250C" },
+  "&boxh;": { "codepoints": [9472], "characters": "\u2500" },
+  "&boxhD;": { "codepoints": [9573], "characters": "\u2565" },
+  "&boxhU;": { "codepoints": [9576], "characters": "\u2568" },
+  "&boxhd;": { "codepoints": [9516], "characters": "\u252C" },
+  "&boxhu;": { "codepoints": [9524], "characters": "\u2534" },
+  "&boxminus;": { "codepoints": [8863], "characters": "\u229F" },
+  "&boxplus;": { "codepoints": [8862], "characters": "\u229E" },
+  "&boxtimes;": { "codepoints": [8864], "characters": "\u22A0" },
+  "&boxuL;": { "codepoints": [9563], "characters": "\u255B" },
+  "&boxuR;": { "codepoints": [9560], "characters": "\u2558" },
+  "&boxul;": { "codepoints": [9496], "characters": "\u2518" },
+  "&boxur;": { "codepoints": [9492], "characters": "\u2514" },
+  "&boxv;": { "codepoints": [9474], "characters": "\u2502" },
+  "&boxvH;": { "codepoints": [9578], "characters": "\u256A" },
+  "&boxvL;": { "codepoints": [9569], "characters": "\u2561" },
+  "&boxvR;": { "codepoints": [9566], "characters": "\u255E" },
+  "&boxvh;": { "codepoints": [9532], "characters": "\u253C" },
+  "&boxvl;": { "codepoints": [9508], "characters": "\u2524" },
+  "&boxvr;": { "codepoints": [9500], "characters": "\u251C" },
+  "&bprime;": { "codepoints": [8245], "characters": "\u2035" },
+  "&breve;": { "codepoints": [728], "characters": "\u02D8" },
+  "&brvbar": { "codepoints": [166], "characters": "\u00A6" },
+  "&brvbar;": { "codepoints": [166], "characters": "\u00A6" },
+  "&bscr;": { "codepoints": [119991], "characters": "\uD835\uDCB7" },
+  "&bsemi;": { "codepoints": [8271], "characters": "\u204F" },
+  "&bsim;": { "codepoints": [8765], "characters": "\u223D" },
+  "&bsime;": { "codepoints": [8909], "characters": "\u22CD" },
+  "&bsol;": { "codepoints": [92], "characters": "\u005C" },
+  "&bsolb;": { "codepoints": [10693], "characters": "\u29C5" },
+  "&bsolhsub;": { "codepoints": [10184], "characters": "\u27C8" },
+  "&bull;": { "codepoints": [8226], "characters": "\u2022" },
+  "&bullet;": { "codepoints": [8226], "characters": "\u2022" },
+  "&bump;": { "codepoints": [8782], "characters": "\u224E" },
+  "&bumpE;": { "codepoints": [10926], "characters": "\u2AAE" },
+  "&bumpe;": { "codepoints": [8783], "characters": "\u224F" },
+  "&bumpeq;": { "codepoints": [8783], "characters": "\u224F" },
+  "&cacute;": { "codepoints": [263], "characters": "\u0107" },
+  "&cap;": { "codepoints": [8745], "characters": "\u2229" },
+  "&capand;": { "codepoints": [10820], "characters": "\u2A44" },
+  "&capbrcup;": { "codepoints": [10825], "characters": "\u2A49" },
+  "&capcap;": { "codepoints": [10827], "characters": "\u2A4B" },
+  "&capcup;": { "codepoints": [10823], "characters": "\u2A47" },
+  "&capdot;": { "codepoints": [10816], "characters": "\u2A40" },
+  "&caps;": { "codepoints": [8745, 65024], "characters": "\u2229\uFE00" },
+  "&caret;": { "codepoints": [8257], "characters": "\u2041" },
+  "&caron;": { "codepoints": [711], "characters": "\u02C7" },
+  "&ccaps;": { "codepoints": [10829], "characters": "\u2A4D" },
+  "&ccaron;": { "codepoints": [269], "characters": "\u010D" },
+  "&ccedil": { "codepoints": [231], "characters": "\u00E7" },
+  "&ccedil;": { "codepoints": [231], "characters": "\u00E7" },
+  "&ccirc;": { "codepoints": [265], "characters": "\u0109" },
+  "&ccups;": { "codepoints": [10828], "characters": "\u2A4C" },
+  "&ccupssm;": { "codepoints": [10832], "characters": "\u2A50" },
+  "&cdot;": { "codepoints": [267], "characters": "\u010B" },
+  "&cedil": { "codepoints": [184], "characters": "\u00B8" },
+  "&cedil;": { "codepoints": [184], "characters": "\u00B8" },
+  "&cemptyv;": { "codepoints": [10674], "characters": "\u29B2" },
+  "&cent": { "codepoints": [162], "characters": "\u00A2" },
+  "&cent;": { "codepoints": [162], "characters": "\u00A2" },
+  "&centerdot;": { "codepoints": [183], "characters": "\u00B7" },
+  "&cfr;": { "codepoints": [120096], "characters": "\uD835\uDD20" },
+  "&chcy;": { "codepoints": [1095], "characters": "\u0447" },
+  "&check;": { "codepoints": [10003], "characters": "\u2713" },
+  "&checkmark;": { "codepoints": [10003], "characters": "\u2713" },
+  "&chi;": { "codepoints": [967], "characters": "\u03C7" },
+  "&cir;": { "codepoints": [9675], "characters": "\u25CB" },
+  "&cirE;": { "codepoints": [10691], "characters": "\u29C3" },
+  "&circ;": { "codepoints": [710], "characters": "\u02C6" },
+  "&circeq;": { "codepoints": [8791], "characters": "\u2257" },
+  "&circlearrowleft;": { "codepoints": [8634], "characters": "\u21BA" },
+  "&circlearrowright;": { "codepoints": [8635], "characters": "\u21BB" },
+  "&circledR;": { "codepoints": [174], "characters": "\u00AE" },
+  "&circledS;": { "codepoints": [9416], "characters": "\u24C8" },
+  "&circledast;": { "codepoints": [8859], "characters": "\u229B" },
+  "&circledcirc;": { "codepoints": [8858], "characters": "\u229A" },
+  "&circleddash;": { "codepoints": [8861], "characters": "\u229D" },
+  "&cire;": { "codepoints": [8791], "characters": "\u2257" },
+  "&cirfnint;": { "codepoints": [10768], "characters": "\u2A10" },
+  "&cirmid;": { "codepoints": [10991], "characters": "\u2AEF" },
+  "&cirscir;": { "codepoints": [10690], "characters": "\u29C2" },
+  "&clubs;": { "codepoints": [9827], "characters": "\u2663" },
+  "&clubsuit;": { "codepoints": [9827], "characters": "\u2663" },
+  "&colon;": { "codepoints": [58], "characters": "\u003A" },
+  "&colone;": { "codepoints": [8788], "characters": "\u2254" },
+  "&coloneq;": { "codepoints": [8788], "characters": "\u2254" },
+  "&comma;": { "codepoints": [44], "characters": "\u002C" },
+  "&commat;": { "codepoints": [64], "characters": "\u0040" },
+  "&comp;": { "codepoints": [8705], "characters": "\u2201" },
+  "&compfn;": { "codepoints": [8728], "characters": "\u2218" },
+  "&complement;": { "codepoints": [8705], "characters": "\u2201" },
+  "&complexes;": { "codepoints": [8450], "characters": "\u2102" },
+  "&cong;": { "codepoints": [8773], "characters": "\u2245" },
+  "&congdot;": { "codepoints": [10861], "characters": "\u2A6D" },
+  "&conint;": { "codepoints": [8750], "characters": "\u222E" },
+  "&copf;": { "codepoints": [120148], "characters": "\uD835\uDD54" },
+  "&coprod;": { "codepoints": [8720], "characters": "\u2210" },
+  "&copy": { "codepoints": [169], "characters": "\u00A9" },
+  "&copy;": { "codepoints": [169], "characters": "\u00A9" },
+  "&copysr;": { "codepoints": [8471], "characters": "\u2117" },
+  "&crarr;": { "codepoints": [8629], "characters": "\u21B5" },
+  "&cross;": { "codepoints": [10007], "characters": "\u2717" },
+  "&cscr;": { "codepoints": [119992], "characters": "\uD835\uDCB8" },
+  "&csub;": { "codepoints": [10959], "characters": "\u2ACF" },
+  "&csube;": { "codepoints": [10961], "characters": "\u2AD1" },
+  "&csup;": { "codepoints": [10960], "characters": "\u2AD0" },
+  "&csupe;": { "codepoints": [10962], "characters": "\u2AD2" },
+  "&ctdot;": { "codepoints": [8943], "characters": "\u22EF" },
+  "&cudarrl;": { "codepoints": [10552], "characters": "\u2938" },
+  "&cudarrr;": { "codepoints": [10549], "characters": "\u2935" },
+  "&cuepr;": { "codepoints": [8926], "characters": "\u22DE" },
+  "&cuesc;": { "codepoints": [8927], "characters": "\u22DF" },
+  "&cularr;": { "codepoints": [8630], "characters": "\u21B6" },
+  "&cularrp;": { "codepoints": [10557], "characters": "\u293D" },
+  "&cup;": { "codepoints": [8746], "characters": "\u222A" },
+  "&cupbrcap;": { "codepoints": [10824], "characters": "\u2A48" },
+  "&cupcap;": { "codepoints": [10822], "characters": "\u2A46" },
+  "&cupcup;": { "codepoints": [10826], "characters": "\u2A4A" },
+  "&cupdot;": { "codepoints": [8845], "characters": "\u228D" },
+  "&cupor;": { "codepoints": [10821], "characters": "\u2A45" },
+  "&cups;": { "codepoints": [8746, 65024], "characters": "\u222A\uFE00" },
+  "&curarr;": { "codepoints": [8631], "characters": "\u21B7" },
+  "&curarrm;": { "codepoints": [10556], "characters": "\u293C" },
+  "&curlyeqprec;": { "codepoints": [8926], "characters": "\u22DE" },
+  "&curlyeqsucc;": { "codepoints": [8927], "characters": "\u22DF" },
+  "&curlyvee;": { "codepoints": [8910], "characters": "\u22CE" },
+  "&curlywedge;": { "codepoints": [8911], "characters": "\u22CF" },
+  "&curren": { "codepoints": [164], "characters": "\u00A4" },
+  "&curren;": { "codepoints": [164], "characters": "\u00A4" },
+  "&curvearrowleft;": { "codepoints": [8630], "characters": "\u21B6" },
+  "&curvearrowright;": { "codepoints": [8631], "characters": "\u21B7" },
+  "&cuvee;": { "codepoints": [8910], "characters": "\u22CE" },
+  "&cuwed;": { "codepoints": [8911], "characters": "\u22CF" },
+  "&cwconint;": { "codepoints": [8754], "characters": "\u2232" },
+  "&cwint;": { "codepoints": [8753], "characters": "\u2231" },
+  "&cylcty;": { "codepoints": [9005], "characters": "\u232D" },
+  "&dArr;": { "codepoints": [8659], "characters": "\u21D3" },
+  "&dHar;": { "codepoints": [10597], "characters": "\u2965" },
+  "&dagger;": { "codepoints": [8224], "characters": "\u2020" },
+  "&daleth;": { "codepoints": [8504], "characters": "\u2138" },
+  "&darr;": { "codepoints": [8595], "characters": "\u2193" },
+  "&dash;": { "codepoints": [8208], "characters": "\u2010" },
+  "&dashv;": { "codepoints": [8867], "characters": "\u22A3" },
+  "&dbkarow;": { "codepoints": [10511], "characters": "\u290F" },
+  "&dblac;": { "codepoints": [733], "characters": "\u02DD" },
+  "&dcaron;": { "codepoints": [271], "characters": "\u010F" },
+  "&dcy;": { "codepoints": [1076], "characters": "\u0434" },
+  "&dd;": { "codepoints": [8518], "characters": "\u2146" },
+  "&ddagger;": { "codepoints": [8225], "characters": "\u2021" },
+  "&ddarr;": { "codepoints": [8650], "characters": "\u21CA" },
+  "&ddotseq;": { "codepoints": [10871], "characters": "\u2A77" },
+  "&deg": { "codepoints": [176], "characters": "\u00B0" },
+  "&deg;": { "codepoints": [176], "characters": "\u00B0" },
+  "&delta;": { "codepoints": [948], "characters": "\u03B4" },
+  "&demptyv;": { "codepoints": [10673], "characters": "\u29B1" },
+  "&dfisht;": { "codepoints": [10623], "characters": "\u297F" },
+  "&dfr;": { "codepoints": [120097], "characters": "\uD835\uDD21" },
+  "&dharl;": { "codepoints": [8643], "characters": "\u21C3" },
+  "&dharr;": { "codepoints": [8642], "characters": "\u21C2" },
+  "&diam;": { "codepoints": [8900], "characters": "\u22C4" },
+  "&diamond;": { "codepoints": [8900], "characters": "\u22C4" },
+  "&diamondsuit;": { "codepoints": [9830], "characters": "\u2666" },
+  "&diams;": { "codepoints": [9830], "characters": "\u2666" },
+  "&die;": { "codepoints": [168], "characters": "\u00A8" },
+  "&digamma;": { "codepoints": [989], "characters": "\u03DD" },
+  "&disin;": { "codepoints": [8946], "characters": "\u22F2" },
+  "&div;": { "codepoints": [247], "characters": "\u00F7" },
+  "&divide": { "codepoints": [247], "characters": "\u00F7" },
+  "&divide;": { "codepoints": [247], "characters": "\u00F7" },
+  "&divideontimes;": { "codepoints": [8903], "characters": "\u22C7" },
+  "&divonx;": { "codepoints": [8903], "characters": "\u22C7" },
+  "&djcy;": { "codepoints": [1106], "characters": "\u0452" },
+  "&dlcorn;": { "codepoints": [8990], "characters": "\u231E" },
+  "&dlcrop;": { "codepoints": [8973], "characters": "\u230D" },
+  "&dollar;": { "codepoints": [36], "characters": "\u0024" },
+  "&dopf;": { "codepoints": [120149], "characters": "\uD835\uDD55" },
+  "&dot;": { "codepoints": [729], "characters": "\u02D9" },
+  "&doteq;": { "codepoints": [8784], "characters": "\u2250" },
+  "&doteqdot;": { "codepoints": [8785], "characters": "\u2251" },
+  "&dotminus;": { "codepoints": [8760], "characters": "\u2238" },
+  "&dotplus;": { "codepoints": [8724], "characters": "\u2214" },
+  "&dotsquare;": { "codepoints": [8865], "characters": "\u22A1" },
+  "&doublebarwedge;": { "codepoints": [8966], "characters": "\u2306" },
+  "&downarrow;": { "codepoints": [8595], "characters": "\u2193" },
+  "&downdownarrows;": { "codepoints": [8650], "characters": "\u21CA" },
+  "&downharpoonleft;": { "codepoints": [8643], "characters": "\u21C3" },
+  "&downharpoonright;": { "codepoints": [8642], "characters": "\u21C2" },
+  "&drbkarow;": { "codepoints": [10512], "characters": "\u2910" },
+  "&drcorn;": { "codepoints": [8991], "characters": "\u231F" },
+  "&drcrop;": { "codepoints": [8972], "characters": "\u230C" },
+  "&dscr;": { "codepoints": [119993], "characters": "\uD835\uDCB9" },
+  "&dscy;": { "codepoints": [1109], "characters": "\u0455" },
+  "&dsol;": { "codepoints": [10742], "characters": "\u29F6" },
+  "&dstrok;": { "codepoints": [273], "characters": "\u0111" },
+  "&dtdot;": { "codepoints": [8945], "characters": "\u22F1" },
+  "&dtri;": { "codepoints": [9663], "characters": "\u25BF" },
+  "&dtrif;": { "codepoints": [9662], "characters": "\u25BE" },
+  "&duarr;": { "codepoints": [8693], "characters": "\u21F5" },
+  "&duhar;": { "codepoints": [10607], "characters": "\u296F" },
+  "&dwangle;": { "codepoints": [10662], "characters": "\u29A6" },
+  "&dzcy;": { "codepoints": [1119], "characters": "\u045F" },
+  "&dzigrarr;": { "codepoints": [10239], "characters": "\u27FF" },
+  "&eDDot;": { "codepoints": [10871], "characters": "\u2A77" },
+  "&eDot;": { "codepoints": [8785], "characters": "\u2251" },
+  "&eacute": { "codepoints": [233], "characters": "\u00E9" },
+  "&eacute;": { "codepoints": [233], "characters": "\u00E9" },
+  "&easter;": { "codepoints": [10862], "characters": "\u2A6E" },
+  "&ecaron;": { "codepoints": [283], "characters": "\u011B" },
+  "&ecir;": { "codepoints": [8790], "characters": "\u2256" },
+  "&ecirc": { "codepoints": [234], "characters": "\u00EA" },
+  "&ecirc;": { "codepoints": [234], "characters": "\u00EA" },
+  "&ecolon;": { "codepoints": [8789], "characters": "\u2255" },
+  "&ecy;": { "codepoints": [1101], "characters": "\u044D" },
+  "&edot;": { "codepoints": [279], "characters": "\u0117" },
+  "&ee;": { "codepoints": [8519], "characters": "\u2147" },
+  "&efDot;": { "codepoints": [8786], "characters": "\u2252" },
+  "&efr;": { "codepoints": [120098], "characters": "\uD835\uDD22" },
+  "&eg;": { "codepoints": [10906], "characters": "\u2A9A" },
+  "&egrave": { "codepoints": [232], "characters": "\u00E8" },
+  "&egrave;": { "codepoints": [232], "characters": "\u00E8" },
+  "&egs;": { "codepoints": [10902], "characters": "\u2A96" },
+  "&egsdot;": { "codepoints": [10904], "characters": "\u2A98" },
+  "&el;": { "codepoints": [10905], "characters": "\u2A99" },
+  "&elinters;": { "codepoints": [9191], "characters": "\u23E7" },
+  "&ell;": { "codepoints": [8467], "characters": "\u2113" },
+  "&els;": { "codepoints": [10901], "characters": "\u2A95" },
+  "&elsdot;": { "codepoints": [10903], "characters": "\u2A97" },
+  "&emacr;": { "codepoints": [275], "characters": "\u0113" },
+  "&empty;": { "codepoints": [8709], "characters": "\u2205" },
+  "&emptyset;": { "codepoints": [8709], "characters": "\u2205" },
+  "&emptyv;": { "codepoints": [8709], "characters": "\u2205" },
+  "&emsp13;": { "codepoints": [8196], "characters": "\u2004" },
+  "&emsp14;": { "codepoints": [8197], "characters": "\u2005" },
+  "&emsp;": { "codepoints": [8195], "characters": "\u2003" },
+  "&eng;": { "codepoints": [331], "characters": "\u014B" },
+  "&ensp;": { "codepoints": [8194], "characters": "\u2002" },
+  "&eogon;": { "codepoints": [281], "characters": "\u0119" },
+  "&eopf;": { "codepoints": [120150], "characters": "\uD835\uDD56" },
+  "&epar;": { "codepoints": [8917], "characters": "\u22D5" },
+  "&eparsl;": { "codepoints": [10723], "characters": "\u29E3" },
+  "&eplus;": { "codepoints": [10865], "characters": "\u2A71" },
+  "&epsi;": { "codepoints": [949], "characters": "\u03B5" },
+  "&epsilon;": { "codepoints": [949], "characters": "\u03B5" },
+  "&epsiv;": { "codepoints": [1013], "characters": "\u03F5" },
+  "&eqcirc;": { "codepoints": [8790], "characters": "\u2256" },
+  "&eqcolon;": { "codepoints": [8789], "characters": "\u2255" },
+  "&eqsim;": { "codepoints": [8770], "characters": "\u2242" },
+  "&eqslantgtr;": { "codepoints": [10902], "characters": "\u2A96" },
+  "&eqslantless;": { "codepoints": [10901], "characters": "\u2A95" },
+  "&equals;": { "codepoints": [61], "characters": "\u003D" },
+  "&equest;": { "codepoints": [8799], "characters": "\u225F" },
+  "&equiv;": { "codepoints": [8801], "characters": "\u2261" },
+  "&equivDD;": { "codepoints": [10872], "characters": "\u2A78" },
+  "&eqvparsl;": { "codepoints": [10725], "characters": "\u29E5" },
+  "&erDot;": { "codepoints": [8787], "characters": "\u2253" },
+  "&erarr;": { "codepoints": [10609], "characters": "\u2971" },
+  "&escr;": { "codepoints": [8495], "characters": "\u212F" },
+  "&esdot;": { "codepoints": [8784], "characters": "\u2250" },
+  "&esim;": { "codepoints": [8770], "characters": "\u2242" },
+  "&eta;": { "codepoints": [951], "characters": "\u03B7" },
+  "&eth": { "codepoints": [240], "characters": "\u00F0" },
+  "&eth;": { "codepoints": [240], "characters": "\u00F0" },
+  "&euml": { "codepoints": [235], "characters": "\u00EB" },
+  "&euml;": { "codepoints": [235], "characters": "\u00EB" },
+  "&euro;": { "codepoints": [8364], "characters": "\u20AC" },
+  "&excl;": { "codepoints": [33], "characters": "\u0021" },
+  "&exist;": { "codepoints": [8707], "characters": "\u2203" },
+  "&expectation;": { "codepoints": [8496], "characters": "\u2130" },
+  "&exponentiale;": { "codepoints": [8519], "characters": "\u2147" },
+  "&fallingdotseq;": { "codepoints": [8786], "characters": "\u2252" },
+  "&fcy;": { "codepoints": [1092], "characters": "\u0444" },
+  "&female;": { "codepoints": [9792], "characters": "\u2640" },
+  "&ffilig;": { "codepoints": [64259], "characters": "\uFB03" },
+  "&fflig;": { "codepoints": [64256], "characters": "\uFB00" },
+  "&ffllig;": { "codepoints": [64260], "characters": "\uFB04" },
+  "&ffr;": { "codepoints": [120099], "characters": "\uD835\uDD23" },
+  "&filig;": { "codepoints": [64257], "characters": "\uFB01" },
+  "&fjlig;": { "codepoints": [102, 106], "characters": "\u0066\u006A" },
+  "&flat;": { "codepoints": [9837], "characters": "\u266D" },
+  "&fllig;": { "codepoints": [64258], "characters": "\uFB02" },
+  "&fltns;": { "codepoints": [9649], "characters": "\u25B1" },
+  "&fnof;": { "codepoints": [402], "characters": "\u0192" },
+  "&fopf;": { "codepoints": [120151], "characters": "\uD835\uDD57" },
+  "&forall;": { "codepoints": [8704], "characters": "\u2200" },
+  "&fork;": { "codepoints": [8916], "characters": "\u22D4" },
+  "&forkv;": { "codepoints": [10969], "characters": "\u2AD9" },
+  "&fpartint;": { "codepoints": [10765], "characters": "\u2A0D" },
+  "&frac12": { "codepoints": [189], "characters": "\u00BD" },
+  "&frac12;": { "codepoints": [189], "characters": "\u00BD" },
+  "&frac13;": { "codepoints": [8531], "characters": "\u2153" },
+  "&frac14": { "codepoints": [188], "characters": "\u00BC" },
+  "&frac14;": { "codepoints": [188], "characters": "\u00BC" },
+  "&frac15;": { "codepoints": [8533], "characters": "\u2155" },
+  "&frac16;": { "codepoints": [8537], "characters": "\u2159" },
+  "&frac18;": { "codepoints": [8539], "characters": "\u215B" },
+  "&frac23;": { "codepoints": [8532], "characters": "\u2154" },
+  "&frac25;": { "codepoints": [8534], "characters": "\u2156" },
+  "&frac34": { "codepoints": [190], "characters": "\u00BE" },
+  "&frac34;": { "codepoints": [190], "characters": "\u00BE" },
+  "&frac35;": { "codepoints": [8535], "characters": "\u2157" },
+  "&frac38;": { "codepoints": [8540], "characters": "\u215C" },
+  "&frac45;": { "codepoints": [8536], "characters": "\u2158" },
+  "&frac56;": { "codepoints": [8538], "characters": "\u215A" },
+  "&frac58;": { "codepoints": [8541], "characters": "\u215D" },
+  "&frac78;": { "codepoints": [8542], "characters": "\u215E" },
+  "&frasl;": { "codepoints": [8260], "characters": "\u2044" },
+  "&frown;": { "codepoints": [8994], "characters": "\u2322" },
+  "&fscr;": { "codepoints": [119995], "characters": "\uD835\uDCBB" },
+  "&gE;": { "codepoints": [8807], "characters": "\u2267" },
+  "&gEl;": { "codepoints": [10892], "characters": "\u2A8C" },
+  "&gacute;": { "codepoints": [501], "characters": "\u01F5" },
+  "&gamma;": { "codepoints": [947], "characters": "\u03B3" },
+  "&gammad;": { "codepoints": [989], "characters": "\u03DD" },
+  "&gap;": { "codepoints": [10886], "characters": "\u2A86" },
+  "&gbreve;": { "codepoints": [287], "characters": "\u011F" },
+  "&gcirc;": { "codepoints": [285], "characters": "\u011D" },
+  "&gcy;": { "codepoints": [1075], "characters": "\u0433" },
+  "&gdot;": { "codepoints": [289], "characters": "\u0121" },
+  "&ge;": { "codepoints": [8805], "characters": "\u2265" },
+  "&gel;": { "codepoints": [8923], "characters": "\u22DB" },
+  "&geq;": { "codepoints": [8805], "characters": "\u2265" },
+  "&geqq;": { "codepoints": [8807], "characters": "\u2267" },
+  "&geqslant;": { "codepoints": [10878], "characters": "\u2A7E" },
+  "&ges;": { "codepoints": [10878], "characters": "\u2A7E" },
+  "&gescc;": { "codepoints": [10921], "characters": "\u2AA9" },
+  "&gesdot;": { "codepoints": [10880], "characters": "\u2A80" },
+  "&gesdoto;": { "codepoints": [10882], "characters": "\u2A82" },
+  "&gesdotol;": { "codepoints": [10884], "characters": "\u2A84" },
+  "&gesl;": { "codepoints": [8923, 65024], "characters": "\u22DB\uFE00" },
+  "&gesles;": { "codepoints": [10900], "characters": "\u2A94" },
+  "&gfr;": { "codepoints": [120100], "characters": "\uD835\uDD24" },
+  "&gg;": { "codepoints": [8811], "characters": "\u226B" },
+  "&ggg;": { "codepoints": [8921], "characters": "\u22D9" },
+  "&gimel;": { "codepoints": [8503], "characters": "\u2137" },
+  "&gjcy;": { "codepoints": [1107], "characters": "\u0453" },
+  "&gl;": { "codepoints": [8823], "characters": "\u2277" },
+  "&glE;": { "codepoints": [10898], "characters": "\u2A92" },
+  "&gla;": { "codepoints": [10917], "characters": "\u2AA5" },
+  "&glj;": { "codepoints": [10916], "characters": "\u2AA4" },
+  "&gnE;": { "codepoints": [8809], "characters": "\u2269" },
+  "&gnap;": { "codepoints": [10890], "characters": "\u2A8A" },
+  "&gnapprox;": { "codepoints": [10890], "characters": "\u2A8A" },
+  "&gne;": { "codepoints": [10888], "characters": "\u2A88" },
+  "&gneq;": { "codepoints": [10888], "characters": "\u2A88" },
+  "&gneqq;": { "codepoints": [8809], "characters": "\u2269" },
+  "&gnsim;": { "codepoints": [8935], "characters": "\u22E7" },
+  "&gopf;": { "codepoints": [120152], "characters": "\uD835\uDD58" },
+  "&grave;": { "codepoints": [96], "characters": "\u0060" },
+  "&gscr;": { "codepoints": [8458], "characters": "\u210A" },
+  "&gsim;": { "codepoints": [8819], "characters": "\u2273" },
+  "&gsime;": { "codepoints": [10894], "characters": "\u2A8E" },
+  "&gsiml;": { "codepoints": [10896], "characters": "\u2A90" },
+  "&gt": { "codepoints": [62], "characters": "\u003E" },
+  "&gt;": { "codepoints": [62], "characters": "\u003E" },
+  "&gtcc;": { "codepoints": [10919], "characters": "\u2AA7" },
+  "&gtcir;": { "codepoints": [10874], "characters": "\u2A7A" },
+  "&gtdot;": { "codepoints": [8919], "characters": "\u22D7" },
+  "&gtlPar;": { "codepoints": [10645], "characters": "\u2995" },
+  "&gtquest;": { "codepoints": [10876], "characters": "\u2A7C" },
+  "&gtrapprox;": { "codepoints": [10886], "characters": "\u2A86" },
+  "&gtrarr;": { "codepoints": [10616], "characters": "\u2978" },
+  "&gtrdot;": { "codepoints": [8919], "characters": "\u22D7" },
+  "&gtreqless;": { "codepoints": [8923], "characters": "\u22DB" },
+  "&gtreqqless;": { "codepoints": [10892], "characters": "\u2A8C" },
+  "&gtrless;": { "codepoints": [8823], "characters": "\u2277" },
+  "&gtrsim;": { "codepoints": [8819], "characters": "\u2273" },
+  "&gvertneqq;": { "codepoints": [8809, 65024], "characters": "\u2269\uFE00" },
+  "&gvnE;": { "codepoints": [8809, 65024], "characters": "\u2269\uFE00" },
+  "&hArr;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&hairsp;": { "codepoints": [8202], "characters": "\u200A" },
+  "&half;": { "codepoints": [189], "characters": "\u00BD" },
+  "&hamilt;": { "codepoints": [8459], "characters": "\u210B" },
+  "&hardcy;": { "codepoints": [1098], "characters": "\u044A" },
+  "&harr;": { "codepoints": [8596], "characters": "\u2194" },
+  "&harrcir;": { "codepoints": [10568], "characters": "\u2948" },
+  "&harrw;": { "codepoints": [8621], "characters": "\u21AD" },
+  "&hbar;": { "codepoints": [8463], "characters": "\u210F" },
+  "&hcirc;": { "codepoints": [293], "characters": "\u0125" },
+  "&hearts;": { "codepoints": [9829], "characters": "\u2665" },
+  "&heartsuit;": { "codepoints": [9829], "characters": "\u2665" },
+  "&hellip;": { "codepoints": [8230], "characters": "\u2026" },
+  "&hercon;": { "codepoints": [8889], "characters": "\u22B9" },
+  "&hfr;": { "codepoints": [120101], "characters": "\uD835\uDD25" },
+  "&hksearow;": { "codepoints": [10533], "characters": "\u2925" },
+  "&hkswarow;": { "codepoints": [10534], "characters": "\u2926" },
+  "&hoarr;": { "codepoints": [8703], "characters": "\u21FF" },
+  "&homtht;": { "codepoints": [8763], "characters": "\u223B" },
+  "&hookleftarrow;": { "codepoints": [8617], "characters": "\u21A9" },
+  "&hookrightarrow;": { "codepoints": [8618], "characters": "\u21AA" },
+  "&hopf;": { "codepoints": [120153], "characters": "\uD835\uDD59" },
+  "&horbar;": { "codepoints": [8213], "characters": "\u2015" },
+  "&hscr;": { "codepoints": [119997], "characters": "\uD835\uDCBD" },
+  "&hslash;": { "codepoints": [8463], "characters": "\u210F" },
+  "&hstrok;": { "codepoints": [295], "characters": "\u0127" },
+  "&hybull;": { "codepoints": [8259], "characters": "\u2043" },
+  "&hyphen;": { "codepoints": [8208], "characters": "\u2010" },
+  "&iacute": { "codepoints": [237], "characters": "\u00ED" },
+  "&iacute;": { "codepoints": [237], "characters": "\u00ED" },
+  "&ic;": { "codepoints": [8291], "characters": "\u2063" },
+  "&icirc": { "codepoints": [238], "characters": "\u00EE" },
+  "&icirc;": { "codepoints": [238], "characters": "\u00EE" },
+  "&icy;": { "codepoints": [1080], "characters": "\u0438" },
+  "&iecy;": { "codepoints": [1077], "characters": "\u0435" },
+  "&iexcl": { "codepoints": [161], "characters": "\u00A1" },
+  "&iexcl;": { "codepoints": [161], "characters": "\u00A1" },
+  "&iff;": { "codepoints": [8660], "characters": "\u21D4" },
+  "&ifr;": { "codepoints": [120102], "characters": "\uD835\uDD26" },
+  "&igrave": { "codepoints": [236], "characters": "\u00EC" },
+  "&igrave;": { "codepoints": [236], "characters": "\u00EC" },
+  "&ii;": { "codepoints": [8520], "characters": "\u2148" },
+  "&iiiint;": { "codepoints": [10764], "characters": "\u2A0C" },
+  "&iiint;": { "codepoints": [8749], "characters": "\u222D" },
+  "&iinfin;": { "codepoints": [10716], "characters": "\u29DC" },
+  "&iiota;": { "codepoints": [8489], "characters": "\u2129" },
+  "&ijlig;": { "codepoints": [307], "characters": "\u0133" },
+  "&imacr;": { "codepoints": [299], "characters": "\u012B" },
+  "&image;": { "codepoints": [8465], "characters": "\u2111" },
+  "&imagline;": { "codepoints": [8464], "characters": "\u2110" },
+  "&imagpart;": { "codepoints": [8465], "characters": "\u2111" },
+  "&imath;": { "codepoints": [305], "characters": "\u0131" },
+  "&imof;": { "codepoints": [8887], "characters": "\u22B7" },
+  "&imped;": { "codepoints": [437], "characters": "\u01B5" },
+  "&in;": { "codepoints": [8712], "characters": "\u2208" },
+  "&incare;": { "codepoints": [8453], "characters": "\u2105" },
+  "&infin;": { "codepoints": [8734], "characters": "\u221E" },
+  "&infintie;": { "codepoints": [10717], "characters": "\u29DD" },
+  "&inodot;": { "codepoints": [305], "characters": "\u0131" },
+  "&int;": { "codepoints": [8747], "characters": "\u222B" },
+  "&intcal;": { "codepoints": [8890], "characters": "\u22BA" },
+  "&integers;": { "codepoints": [8484], "characters": "\u2124" },
+  "&intercal;": { "codepoints": [8890], "characters": "\u22BA" },
+  "&intlarhk;": { "codepoints": [10775], "characters": "\u2A17" },
+  "&intprod;": { "codepoints": [10812], "characters": "\u2A3C" },
+  "&iocy;": { "codepoints": [1105], "characters": "\u0451" },
+  "&iogon;": { "codepoints": [303], "characters": "\u012F" },
+  "&iopf;": { "codepoints": [120154], "characters": "\uD835\uDD5A" },
+  "&iota;": { "codepoints": [953], "characters": "\u03B9" },
+  "&iprod;": { "codepoints": [10812], "characters": "\u2A3C" },
+  "&iquest": { "codepoints": [191], "characters": "\u00BF" },
+  "&iquest;": { "codepoints": [191], "characters": "\u00BF" },
+  "&iscr;": { "codepoints": [119998], "characters": "\uD835\uDCBE" },
+  "&isin;": { "codepoints": [8712], "characters": "\u2208" },
+  "&isinE;": { "codepoints": [8953], "characters": "\u22F9" },
+  "&isindot;": { "codepoints": [8949], "characters": "\u22F5" },
+  "&isins;": { "codepoints": [8948], "characters": "\u22F4" },
+  "&isinsv;": { "codepoints": [8947], "characters": "\u22F3" },
+  "&isinv;": { "codepoints": [8712], "characters": "\u2208" },
+  "&it;": { "codepoints": [8290], "characters": "\u2062" },
+  "&itilde;": { "codepoints": [297], "characters": "\u0129" },
+  "&iukcy;": { "codepoints": [1110], "characters": "\u0456" },
+  "&iuml": { "codepoints": [239], "characters": "\u00EF" },
+  "&iuml;": { "codepoints": [239], "characters": "\u00EF" },
+  "&jcirc;": { "codepoints": [309], "characters": "\u0135" },
+  "&jcy;": { "codepoints": [1081], "characters": "\u0439" },
+  "&jfr;": { "codepoints": [120103], "characters": "\uD835\uDD27" },
+  "&jmath;": { "codepoints": [567], "characters": "\u0237" },
+  "&jopf;": { "codepoints": [120155], "characters": "\uD835\uDD5B" },
+  "&jscr;": { "codepoints": [119999], "characters": "\uD835\uDCBF" },
+  "&jsercy;": { "codepoints": [1112], "characters": "\u0458" },
+  "&jukcy;": { "codepoints": [1108], "characters": "\u0454" },
+  "&kappa;": { "codepoints": [954], "characters": "\u03BA" },
+  "&kappav;": { "codepoints": [1008], "characters": "\u03F0" },
+  "&kcedil;": { "codepoints": [311], "characters": "\u0137" },
+  "&kcy;": { "codepoints": [1082], "characters": "\u043A" },
+  "&kfr;": { "codepoints": [120104], "characters": "\uD835\uDD28" },
+  "&kgreen;": { "codepoints": [312], "characters": "\u0138" },
+  "&khcy;": { "codepoints": [1093], "characters": "\u0445" },
+  "&kjcy;": { "codepoints": [1116], "characters": "\u045C" },
+  "&kopf;": { "codepoints": [120156], "characters": "\uD835\uDD5C" },
+  "&kscr;": { "codepoints": [120000], "characters": "\uD835\uDCC0" },
+  "&lAarr;": { "codepoints": [8666], "characters": "\u21DA" },
+  "&lArr;": { "codepoints": [8656], "characters": "\u21D0" },
+  "&lAtail;": { "codepoints": [10523], "characters": "\u291B" },
+  "&lBarr;": { "codepoints": [10510], "characters": "\u290E" },
+  "&lE;": { "codepoints": [8806], "characters": "\u2266" },
+  "&lEg;": { "codepoints": [10891], "characters": "\u2A8B" },
+  "&lHar;": { "codepoints": [10594], "characters": "\u2962" },
+  "&lacute;": { "codepoints": [314], "characters": "\u013A" },
+  "&laemptyv;": { "codepoints": [10676], "characters": "\u29B4" },
+  "&lagran;": { "codepoints": [8466], "characters": "\u2112" },
+  "&lambda;": { "codepoints": [955], "characters": "\u03BB" },
+  "&lang;": { "codepoints": [10216], "characters": "\u27E8" },
+  "&langd;": { "codepoints": [10641], "characters": "\u2991" },
+  "&langle;": { "codepoints": [10216], "characters": "\u27E8" },
+  "&lap;": { "codepoints": [10885], "characters": "\u2A85" },
+  "&laquo": { "codepoints": [171], "characters": "\u00AB" },
+  "&laquo;": { "codepoints": [171], "characters": "\u00AB" },
+  "&larr;": { "codepoints": [8592], "characters": "\u2190" },
+  "&larrb;": { "codepoints": [8676], "characters": "\u21E4" },
+  "&larrbfs;": { "codepoints": [10527], "characters": "\u291F" },
+  "&larrfs;": { "codepoints": [10525], "characters": "\u291D" },
+  "&larrhk;": { "codepoints": [8617], "characters": "\u21A9" },
+  "&larrlp;": { "codepoints": [8619], "characters": "\u21AB" },
+  "&larrpl;": { "codepoints": [10553], "characters": "\u2939" },
+  "&larrsim;": { "codepoints": [10611], "characters": "\u2973" },
+  "&larrtl;": { "codepoints": [8610], "characters": "\u21A2" },
+  "&lat;": { "codepoints": [10923], "characters": "\u2AAB" },
+  "&latail;": { "codepoints": [10521], "characters": "\u2919" },
+  "&late;": { "codepoints": [10925], "characters": "\u2AAD" },
+  "&lates;": { "codepoints": [10925, 65024], "characters": "\u2AAD\uFE00" },
+  "&lbarr;": { "codepoints": [10508], "characters": "\u290C" },
+  "&lbbrk;": { "codepoints": [10098], "characters": "\u2772" },
+  "&lbrace;": { "codepoints": [123], "characters": "\u007B" },
+  "&lbrack;": { "codepoints": [91], "characters": "\u005B" },
+  "&lbrke;": { "codepoints": [10635], "characters": "\u298B" },
+  "&lbrksld;": { "codepoints": [10639], "characters": "\u298F" },
+  "&lbrkslu;": { "codepoints": [10637], "characters": "\u298D" },
+  "&lcaron;": { "codepoints": [318], "characters": "\u013E" },
+  "&lcedil;": { "codepoints": [316], "characters": "\u013C" },
+  "&lceil;": { "codepoints": [8968], "characters": "\u2308" },
+  "&lcub;": { "codepoints": [123], "characters": "\u007B" },
+  "&lcy;": { "codepoints": [1083], "characters": "\u043B" },
+  "&ldca;": { "codepoints": [10550], "characters": "\u2936" },
+  "&ldquo;": { "codepoints": [8220], "characters": "\u201C" },
+  "&ldquor;": { "codepoints": [8222], "characters": "\u201E" },
+  "&ldrdhar;": { "codepoints": [10599], "characters": "\u2967" },
+  "&ldrushar;": { "codepoints": [10571], "characters": "\u294B" },
+  "&ldsh;": { "codepoints": [8626], "characters": "\u21B2" },
+  "&le;": { "codepoints": [8804], "characters": "\u2264" },
+  "&leftarrow;": { "codepoints": [8592], "characters": "\u2190" },
+  "&leftarrowtail;": { "codepoints": [8610], "characters": "\u21A2" },
+  "&leftharpoondown;": { "codepoints": [8637], "characters": "\u21BD" },
+  "&leftharpoonup;": { "codepoints": [8636], "characters": "\u21BC" },
+  "&leftleftarrows;": { "codepoints": [8647], "characters": "\u21C7" },
+  "&leftrightarrow;": { "codepoints": [8596], "characters": "\u2194" },
+  "&leftrightarrows;": { "codepoints": [8646], "characters": "\u21C6" },
+  "&leftrightharpoons;": { "codepoints": [8651], "characters": "\u21CB" },
+  "&leftrightsquigarrow;": { "codepoints": [8621], "characters": "\u21AD" },
+  "&leftthreetimes;": { "codepoints": [8907], "characters": "\u22CB" },
+  "&leg;": { "codepoints": [8922], "characters": "\u22DA" },
+  "&leq;": { "codepoints": [8804], "characters": "\u2264" },
+  "&leqq;": { "codepoints": [8806], "characters": "\u2266" },
+  "&leqslant;": { "codepoints": [10877], "characters": "\u2A7D" },
+  "&les;": { "codepoints": [10877], "characters": "\u2A7D" },
+  "&lescc;": { "codepoints": [10920], "characters": "\u2AA8" },
+  "&lesdot;": { "codepoints": [10879], "characters": "\u2A7F" },
+  "&lesdoto;": { "codepoints": [10881], "characters": "\u2A81" },
+  "&lesdotor;": { "codepoints": [10883], "characters": "\u2A83" },
+  "&lesg;": { "codepoints": [8922, 65024], "characters": "\u22DA\uFE00" },
+  "&lesges;": { "codepoints": [10899], "characters": "\u2A93" },
+  "&lessapprox;": { "codepoints": [10885], "characters": "\u2A85" },
+  "&lessdot;": { "codepoints": [8918], "characters": "\u22D6" },
+  "&lesseqgtr;": { "codepoints": [8922], "characters": "\u22DA" },
+  "&lesseqqgtr;": { "codepoints": [10891], "characters": "\u2A8B" },
+  "&lessgtr;": { "codepoints": [8822], "characters": "\u2276" },
+  "&lesssim;": { "codepoints": [8818], "characters": "\u2272" },
+  "&lfisht;": { "codepoints": [10620], "characters": "\u297C" },
+  "&lfloor;": { "codepoints": [8970], "characters": "\u230A" },
+  "&lfr;": { "codepoints": [120105], "characters": "\uD835\uDD29" },
+  "&lg;": { "codepoints": [8822], "characters": "\u2276" },
+  "&lgE;": { "codepoints": [10897], "characters": "\u2A91" },
+  "&lhard;": { "codepoints": [8637], "characters": "\u21BD" },
+  "&lharu;": { "codepoints": [8636], "characters": "\u21BC" },
+  "&lharul;": { "codepoints": [10602], "characters": "\u296A" },
+  "&lhblk;": { "codepoints": [9604], "characters": "\u2584" },
+  "&ljcy;": { "codepoints": [1113], "characters": "\u0459" },
+  "&ll;": { "codepoints": [8810], "characters": "\u226A" },
+  "&llarr;": { "codepoints": [8647], "characters": "\u21C7" },
+  "&llcorner;": { "codepoints": [8990], "characters": "\u231E" },
+  "&llhard;": { "codepoints": [10603], "characters": "\u296B" },
+  "&lltri;": { "codepoints": [9722], "characters": "\u25FA" },
+  "&lmidot;": { "codepoints": [320], "characters": "\u0140" },
+  "&lmoust;": { "codepoints": [9136], "characters": "\u23B0" },
+  "&lmoustache;": { "codepoints": [9136], "characters": "\u23B0" },
+  "&lnE;": { "codepoints": [8808], "characters": "\u2268" },
+  "&lnap;": { "codepoints": [10889], "characters": "\u2A89" },
+  "&lnapprox;": { "codepoints": [10889], "characters": "\u2A89" },
+  "&lne;": { "codepoints": [10887], "characters": "\u2A87" },
+  "&lneq;": { "codepoints": [10887], "characters": "\u2A87" },
+  "&lneqq;": { "codepoints": [8808], "characters": "\u2268" },
+  "&lnsim;": { "codepoints": [8934], "characters": "\u22E6" },
+  "&loang;": { "codepoints": [10220], "characters": "\u27EC" },
+  "&loarr;": { "codepoints": [8701], "characters": "\u21FD" },
+  "&lobrk;": { "codepoints": [10214], "characters": "\u27E6" },
+  "&longleftarrow;": { "codepoints": [10229], "characters": "\u27F5" },
+  "&longleftrightarrow;": { "codepoints": [10231], "characters": "\u27F7" },
+  "&longmapsto;": { "codepoints": [10236], "characters": "\u27FC" },
+  "&longrightarrow;": { "codepoints": [10230], "characters": "\u27F6" },
+  "&looparrowleft;": { "codepoints": [8619], "characters": "\u21AB" },
+  "&looparrowright;": { "codepoints": [8620], "characters": "\u21AC" },
+  "&lopar;": { "codepoints": [10629], "characters": "\u2985" },
+  "&lopf;": { "codepoints": [120157], "characters": "\uD835\uDD5D" },
+  "&loplus;": { "codepoints": [10797], "characters": "\u2A2D" },
+  "&lotimes;": { "codepoints": [10804], "characters": "\u2A34" },
+  "&lowast;": { "codepoints": [8727], "characters": "\u2217" },
+  "&lowbar;": { "codepoints": [95], "characters": "\u005F" },
+  "&loz;": { "codepoints": [9674], "characters": "\u25CA" },
+  "&lozenge;": { "codepoints": [9674], "characters": "\u25CA" },
+  "&lozf;": { "codepoints": [10731], "characters": "\u29EB" },
+  "&lpar;": { "codepoints": [40], "characters": "\u0028" },
+  "&lparlt;": { "codepoints": [10643], "characters": "\u2993" },
+  "&lrarr;": { "codepoints": [8646], "characters": "\u21C6" },
+  "&lrcorner;": { "codepoints": [8991], "characters": "\u231F" },
+  "&lrhar;": { "codepoints": [8651], "characters": "\u21CB" },
+  "&lrhard;": { "codepoints": [10605], "characters": "\u296D" },
+  "&lrm;": { "codepoints": [8206], "characters": "\u200E" },
+  "&lrtri;": { "codepoints": [8895], "characters": "\u22BF" },
+  "&lsaquo;": { "codepoints": [8249], "characters": "\u2039" },
+  "&lscr;": { "codepoints": [120001], "characters": "\uD835\uDCC1" },
+  "&lsh;": { "codepoints": [8624], "characters": "\u21B0" },
+  "&lsim;": { "codepoints": [8818], "characters": "\u2272" },
+  "&lsime;": { "codepoints": [10893], "characters": "\u2A8D" },
+  "&lsimg;": { "codepoints": [10895], "characters": "\u2A8F" },
+  "&lsqb;": { "codepoints": [91], "characters": "\u005B" },
+  "&lsquo;": { "codepoints": [8216], "characters": "\u2018" },
+  "&lsquor;": { "codepoints": [8218], "characters": "\u201A" },
+  "&lstrok;": { "codepoints": [322], "characters": "\u0142" },
+  "&lt": { "codepoints": [60], "characters": "\u003C" },
+  "&lt;": { "codepoints": [60], "characters": "\u003C" },
+  "&ltcc;": { "codepoints": [10918], "characters": "\u2AA6" },
+  "&ltcir;": { "codepoints": [10873], "characters": "\u2A79" },
+  "&ltdot;": { "codepoints": [8918], "characters": "\u22D6" },
+  "&lthree;": { "codepoints": [8907], "characters": "\u22CB" },
+  "&ltimes;": { "codepoints": [8905], "characters": "\u22C9" },
+  "&ltlarr;": { "codepoints": [10614], "characters": "\u2976" },
+  "&ltquest;": { "codepoints": [10875], "characters": "\u2A7B" },
+  "&ltrPar;": { "codepoints": [10646], "characters": "\u2996" },
+  "&ltri;": { "codepoints": [9667], "characters": "\u25C3" },
+  "&ltrie;": { "codepoints": [8884], "characters": "\u22B4" },
+  "&ltrif;": { "codepoints": [9666], "characters": "\u25C2" },
+  "&lurdshar;": { "codepoints": [10570], "characters": "\u294A" },
+  "&luruhar;": { "codepoints": [10598], "characters": "\u2966" },
+  "&lvertneqq;": { "codepoints": [8808, 65024], "characters": "\u2268\uFE00" },
+  "&lvnE;": { "codepoints": [8808, 65024], "characters": "\u2268\uFE00" },
+  "&mDDot;": { "codepoints": [8762], "characters": "\u223A" },
+  "&macr": { "codepoints": [175], "characters": "\u00AF" },
+  "&macr;": { "codepoints": [175], "characters": "\u00AF" },
+  "&male;": { "codepoints": [9794], "characters": "\u2642" },
+  "&malt;": { "codepoints": [10016], "characters": "\u2720" },
+  "&maltese;": { "codepoints": [10016], "characters": "\u2720" },
+  "&map;": { "codepoints": [8614], "characters": "\u21A6" },
+  "&mapsto;": { "codepoints": [8614], "characters": "\u21A6" },
+  "&mapstodown;": { "codepoints": [8615], "characters": "\u21A7" },
+  "&mapstoleft;": { "codepoints": [8612], "characters": "\u21A4" },
+  "&mapstoup;": { "codepoints": [8613], "characters": "\u21A5" },
+  "&marker;": { "codepoints": [9646], "characters": "\u25AE" },
+  "&mcomma;": { "codepoints": [10793], "characters": "\u2A29" },
+  "&mcy;": { "codepoints": [1084], "characters": "\u043C" },
+  "&mdash;": { "codepoints": [8212], "characters": "\u2014" },
+  "&measuredangle;": { "codepoints": [8737], "characters": "\u2221" },
+  "&mfr;": { "codepoints": [120106], "characters": "\uD835\uDD2A" },
+  "&mho;": { "codepoints": [8487], "characters": "\u2127" },
+  "&micro": { "codepoints": [181], "characters": "\u00B5" },
+  "&micro;": { "codepoints": [181], "characters": "\u00B5" },
+  "&mid;": { "codepoints": [8739], "characters": "\u2223" },
+  "&midast;": { "codepoints": [42], "characters": "\u002A" },
+  "&midcir;": { "codepoints": [10992], "characters": "\u2AF0" },
+  "&middot": { "codepoints": [183], "characters": "\u00B7" },
+  "&middot;": { "codepoints": [183], "characters": "\u00B7" },
+  "&minus;": { "codepoints": [8722], "characters": "\u2212" },
+  "&minusb;": { "codepoints": [8863], "characters": "\u229F" },
+  "&minusd;": { "codepoints": [8760], "characters": "\u2238" },
+  "&minusdu;": { "codepoints": [10794], "characters": "\u2A2A" },
+  "&mlcp;": { "codepoints": [10971], "characters": "\u2ADB" },
+  "&mldr;": { "codepoints": [8230], "characters": "\u2026" },
+  "&mnplus;": { "codepoints": [8723], "characters": "\u2213" },
+  "&models;": { "codepoints": [8871], "characters": "\u22A7" },
+  "&mopf;": { "codepoints": [120158], "characters": "\uD835\uDD5E" },
+  "&mp;": { "codepoints": [8723], "characters": "\u2213" },
+  "&mscr;": { "codepoints": [120002], "characters": "\uD835\uDCC2" },
+  "&mstpos;": { "codepoints": [8766], "characters": "\u223E" },
+  "&mu;": { "codepoints": [956], "characters": "\u03BC" },
+  "&multimap;": { "codepoints": [8888], "characters": "\u22B8" },
+  "&mumap;": { "codepoints": [8888], "characters": "\u22B8" },
+  "&nGg;": { "codepoints": [8921, 824], "characters": "\u22D9\u0338" },
+  "&nGt;": { "codepoints": [8811, 8402], "characters": "\u226B\u20D2" },
+  "&nGtv;": { "codepoints": [8811, 824], "characters": "\u226B\u0338" },
+  "&nLeftarrow;": { "codepoints": [8653], "characters": "\u21CD" },
+  "&nLeftrightarrow;": { "codepoints": [8654], "characters": "\u21CE" },
+  "&nLl;": { "codepoints": [8920, 824], "characters": "\u22D8\u0338" },
+  "&nLt;": { "codepoints": [8810, 8402], "characters": "\u226A\u20D2" },
+  "&nLtv;": { "codepoints": [8810, 824], "characters": "\u226A\u0338" },
+  "&nRightarrow;": { "codepoints": [8655], "characters": "\u21CF" },
+  "&nVDash;": { "codepoints": [8879], "characters": "\u22AF" },
+  "&nVdash;": { "codepoints": [8878], "characters": "\u22AE" },
+  "&nabla;": { "codepoints": [8711], "characters": "\u2207" },
+  "&nacute;": { "codepoints": [324], "characters": "\u0144" },
+  "&nang;": { "codepoints": [8736, 8402], "characters": "\u2220\u20D2" },
+  "&nap;": { "codepoints": [8777], "characters": "\u2249" },
+  "&napE;": { "codepoints": [10864, 824], "characters": "\u2A70\u0338" },
+  "&napid;": { "codepoints": [8779, 824], "characters": "\u224B\u0338" },
+  "&napos;": { "codepoints": [329], "characters": "\u0149" },
+  "&napprox;": { "codepoints": [8777], "characters": "\u2249" },
+  "&natur;": { "codepoints": [9838], "characters": "\u266E" },
+  "&natural;": { "codepoints": [9838], "characters": "\u266E" },
+  "&naturals;": { "codepoints": [8469], "characters": "\u2115" },
+  "&nbsp": { "codepoints": [160], "characters": "\u00A0" },
+  "&nbsp;": { "codepoints": [160], "characters": "\u00A0" },
+  "&nbump;": { "codepoints": [8782, 824], "characters": "\u224E\u0338" },
+  "&nbumpe;": { "codepoints": [8783, 824], "characters": "\u224F\u0338" },
+  "&ncap;": { "codepoints": [10819], "characters": "\u2A43" },
+  "&ncaron;": { "codepoints": [328], "characters": "\u0148" },
+  "&ncedil;": { "codepoints": [326], "characters": "\u0146" },
+  "&ncong;": { "codepoints": [8775], "characters": "\u2247" },
+  "&ncongdot;": { "codepoints": [10861, 824], "characters": "\u2A6D\u0338" },
+  "&ncup;": { "codepoints": [10818], "characters": "\u2A42" },
+  "&ncy;": { "codepoints": [1085], "characters": "\u043D" },
+  "&ndash;": { "codepoints": [8211], "characters": "\u2013" },
+  "&ne;": { "codepoints": [8800], "characters": "\u2260" },
+  "&neArr;": { "codepoints": [8663], "characters": "\u21D7" },
+  "&nearhk;": { "codepoints": [10532], "characters": "\u2924" },
+  "&nearr;": { "codepoints": [8599], "characters": "\u2197" },
+  "&nearrow;": { "codepoints": [8599], "characters": "\u2197" },
+  "&nedot;": { "codepoints": [8784, 824], "characters": "\u2250\u0338" },
+  "&nequiv;": { "codepoints": [8802], "characters": "\u2262" },
+  "&nesear;": { "codepoints": [10536], "characters": "\u2928" },
+  "&nesim;": { "codepoints": [8770, 824], "characters": "\u2242\u0338" },
+  "&nexist;": { "codepoints": [8708], "characters": "\u2204" },
+  "&nexists;": { "codepoints": [8708], "characters": "\u2204" },
+  "&nfr;": { "codepoints": [120107], "characters": "\uD835\uDD2B" },
+  "&ngE;": { "codepoints": [8807, 824], "characters": "\u2267\u0338" },
+  "&nge;": { "codepoints": [8817], "characters": "\u2271" },
+  "&ngeq;": { "codepoints": [8817], "characters": "\u2271" },
+  "&ngeqq;": { "codepoints": [8807, 824], "characters": "\u2267\u0338" },
+  "&ngeqslant;": { "codepoints": [10878, 824], "characters": "\u2A7E\u0338" },
+  "&nges;": { "codepoints": [10878, 824], "characters": "\u2A7E\u0338" },
+  "&ngsim;": { "codepoints": [8821], "characters": "\u2275" },
+  "&ngt;": { "codepoints": [8815], "characters": "\u226F" },
+  "&ngtr;": { "codepoints": [8815], "characters": "\u226F" },
+  "&nhArr;": { "codepoints": [8654], "characters": "\u21CE" },
+  "&nharr;": { "codepoints": [8622], "characters": "\u21AE" },
+  "&nhpar;": { "codepoints": [10994], "characters": "\u2AF2" },
+  "&ni;": { "codepoints": [8715], "characters": "\u220B" },
+  "&nis;": { "codepoints": [8956], "characters": "\u22FC" },
+  "&nisd;": { "codepoints": [8954], "characters": "\u22FA" },
+  "&niv;": { "codepoints": [8715], "characters": "\u220B" },
+  "&njcy;": { "codepoints": [1114], "characters": "\u045A" },
+  "&nlArr;": { "codepoints": [8653], "characters": "\u21CD" },
+  "&nlE;": { "codepoints": [8806, 824], "characters": "\u2266\u0338" },
+  "&nlarr;": { "codepoints": [8602], "characters": "\u219A" },
+  "&nldr;": { "codepoints": [8229], "characters": "\u2025" },
+  "&nle;": { "codepoints": [8816], "characters": "\u2270" },
+  "&nleftarrow;": { "codepoints": [8602], "characters": "\u219A" },
+  "&nleftrightarrow;": { "codepoints": [8622], "characters": "\u21AE" },
+  "&nleq;": { "codepoints": [8816], "characters": "\u2270" },
+  "&nleqq;": { "codepoints": [8806, 824], "characters": "\u2266\u0338" },
+  "&nleqslant;": { "codepoints": [10877, 824], "characters": "\u2A7D\u0338" },
+  "&nles;": { "codepoints": [10877, 824], "characters": "\u2A7D\u0338" },
+  "&nless;": { "codepoints": [8814], "characters": "\u226E" },
+  "&nlsim;": { "codepoints": [8820], "characters": "\u2274" },
+  "&nlt;": { "codepoints": [8814], "characters": "\u226E" },
+  "&nltri;": { "codepoints": [8938], "characters": "\u22EA" },
+  "&nltrie;": { "codepoints": [8940], "characters": "\u22EC" },
+  "&nmid;": { "codepoints": [8740], "characters": "\u2224" },
+  "&nopf;": { "codepoints": [120159], "characters": "\uD835\uDD5F" },
+  "&not": { "codepoints": [172], "characters": "\u00AC" },
+  "&not;": { "codepoints": [172], "characters": "\u00AC" },
+  "&notin;": { "codepoints": [8713], "characters": "\u2209" },
+  "&notinE;": { "codepoints": [8953, 824], "characters": "\u22F9\u0338" },
+  "&notindot;": { "codepoints": [8949, 824], "characters": "\u22F5\u0338" },
+  "&notinva;": { "codepoints": [8713], "characters": "\u2209" },
+  "&notinvb;": { "codepoints": [8951], "characters": "\u22F7" },
+  "&notinvc;": { "codepoints": [8950], "characters": "\u22F6" },
+  "&notni;": { "codepoints": [8716], "characters": "\u220C" },
+  "&notniva;": { "codepoints": [8716], "characters": "\u220C" },
+  "&notnivb;": { "codepoints": [8958], "characters": "\u22FE" },
+  "&notnivc;": { "codepoints": [8957], "characters": "\u22FD" },
+  "&npar;": { "codepoints": [8742], "characters": "\u2226" },
+  "&nparallel;": { "codepoints": [8742], "characters": "\u2226" },
+  "&nparsl;": { "codepoints": [11005, 8421], "characters": "\u2AFD\u20E5" },
+  "&npart;": { "codepoints": [8706, 824], "characters": "\u2202\u0338" },
+  "&npolint;": { "codepoints": [10772], "characters": "\u2A14" },
+  "&npr;": { "codepoints": [8832], "characters": "\u2280" },
+  "&nprcue;": { "codepoints": [8928], "characters": "\u22E0" },
+  "&npre;": { "codepoints": [10927, 824], "characters": "\u2AAF\u0338" },
+  "&nprec;": { "codepoints": [8832], "characters": "\u2280" },
+  "&npreceq;": { "codepoints": [10927, 824], "characters": "\u2AAF\u0338" },
+  "&nrArr;": { "codepoints": [8655], "characters": "\u21CF" },
+  "&nrarr;": { "codepoints": [8603], "characters": "\u219B" },
+  "&nrarrc;": { "codepoints": [10547, 824], "characters": "\u2933\u0338" },
+  "&nrarrw;": { "codepoints": [8605, 824], "characters": "\u219D\u0338" },
+  "&nrightarrow;": { "codepoints": [8603], "characters": "\u219B" },
+  "&nrtri;": { "codepoints": [8939], "characters": "\u22EB" },
+  "&nrtrie;": { "codepoints": [8941], "characters": "\u22ED" },
+  "&nsc;": { "codepoints": [8833], "characters": "\u2281" },
+  "&nsccue;": { "codepoints": [8929], "characters": "\u22E1" },
+  "&nsce;": { "codepoints": [10928, 824], "characters": "\u2AB0\u0338" },
+  "&nscr;": { "codepoints": [120003], "characters": "\uD835\uDCC3" },
+  "&nshortmid;": { "codepoints": [8740], "characters": "\u2224" },
+  "&nshortparallel;": { "codepoints": [8742], "characters": "\u2226" },
+  "&nsim;": { "codepoints": [8769], "characters": "\u2241" },
+  "&nsime;": { "codepoints": [8772], "characters": "\u2244" },
+  "&nsimeq;": { "codepoints": [8772], "characters": "\u2244" },
+  "&nsmid;": { "codepoints": [8740], "characters": "\u2224" },
+  "&nspar;": { "codepoints": [8742], "characters": "\u2226" },
+  "&nsqsube;": { "codepoints": [8930], "characters": "\u22E2" },
+  "&nsqsupe;": { "codepoints": [8931], "characters": "\u22E3" },
+  "&nsub;": { "codepoints": [8836], "characters": "\u2284" },
+  "&nsubE;": { "codepoints": [10949, 824], "characters": "\u2AC5\u0338" },
+  "&nsube;": { "codepoints": [8840], "characters": "\u2288" },
+  "&nsubset;": { "codepoints": [8834, 8402], "characters": "\u2282\u20D2" },
+  "&nsubseteq;": { "codepoints": [8840], "characters": "\u2288" },
+  "&nsubseteqq;": { "codepoints": [10949, 824], "characters": "\u2AC5\u0338" },
+  "&nsucc;": { "codepoints": [8833], "characters": "\u2281" },
+  "&nsucceq;": { "codepoints": [10928, 824], "characters": "\u2AB0\u0338" },
+  "&nsup;": { "codepoints": [8837], "characters": "\u2285" },
+  "&nsupE;": { "codepoints": [10950, 824], "characters": "\u2AC6\u0338" },
+  "&nsupe;": { "codepoints": [8841], "characters": "\u2289" },
+  "&nsupset;": { "codepoints": [8835, 8402], "characters": "\u2283\u20D2" },
+  "&nsupseteq;": { "codepoints": [8841], "characters": "\u2289" },
+  "&nsupseteqq;": { "codepoints": [10950, 824], "characters": "\u2AC6\u0338" },
+  "&ntgl;": { "codepoints": [8825], "characters": "\u2279" },
+  "&ntilde": { "codepoints": [241], "characters": "\u00F1" },
+  "&ntilde;": { "codepoints": [241], "characters": "\u00F1" },
+  "&ntlg;": { "codepoints": [8824], "characters": "\u2278" },
+  "&ntriangleleft;": { "codepoints": [8938], "characters": "\u22EA" },
+  "&ntrianglelefteq;": { "codepoints": [8940], "characters": "\u22EC" },
+  "&ntriangleright;": { "codepoints": [8939], "characters": "\u22EB" },
+  "&ntrianglerighteq;": { "codepoints": [8941], "characters": "\u22ED" },
+  "&nu;": { "codepoints": [957], "characters": "\u03BD" },
+  "&num;": { "codepoints": [35], "characters": "\u0023" },
+  "&numero;": { "codepoints": [8470], "characters": "\u2116" },
+  "&numsp;": { "codepoints": [8199], "characters": "\u2007" },
+  "&nvDash;": { "codepoints": [8877], "characters": "\u22AD" },
+  "&nvHarr;": { "codepoints": [10500], "characters": "\u2904" },
+  "&nvap;": { "codepoints": [8781, 8402], "characters": "\u224D\u20D2" },
+  "&nvdash;": { "codepoints": [8876], "characters": "\u22AC" },
+  "&nvge;": { "codepoints": [8805, 8402], "characters": "\u2265\u20D2" },
+  "&nvgt;": { "codepoints": [62, 8402], "characters": "\u003E\u20D2" },
+  "&nvinfin;": { "codepoints": [10718], "characters": "\u29DE" },
+  "&nvlArr;": { "codepoints": [10498], "characters": "\u2902" },
+  "&nvle;": { "codepoints": [8804, 8402], "characters": "\u2264\u20D2" },
+  "&nvlt;": { "codepoints": [60, 8402], "characters": "\u003C\u20D2" },
+  "&nvltrie;": { "codepoints": [8884, 8402], "characters": "\u22B4\u20D2" },
+  "&nvrArr;": { "codepoints": [10499], "characters": "\u2903" },
+  "&nvrtrie;": { "codepoints": [8885, 8402], "characters": "\u22B5\u20D2" },
+  "&nvsim;": { "codepoints": [8764, 8402], "characters": "\u223C\u20D2" },
+  "&nwArr;": { "codepoints": [8662], "characters": "\u21D6" },
+  "&nwarhk;": { "codepoints": [10531], "characters": "\u2923" },
+  "&nwarr;": { "codepoints": [8598], "characters": "\u2196" },
+  "&nwarrow;": { "codepoints": [8598], "characters": "\u2196" },
+  "&nwnear;": { "codepoints": [10535], "characters": "\u2927" },
+  "&oS;": { "codepoints": [9416], "characters": "\u24C8" },
+  "&oacute": { "codepoints": [243], "characters": "\u00F3" },
+  "&oacute;": { "codepoints": [243], "characters": "\u00F3" },
+  "&oast;": { "codepoints": [8859], "characters": "\u229B" },
+  "&ocir;": { "codepoints": [8858], "characters": "\u229A" },
+  "&ocirc": { "codepoints": [244], "characters": "\u00F4" },
+  "&ocirc;": { "codepoints": [244], "characters": "\u00F4" },
+  "&ocy;": { "codepoints": [1086], "characters": "\u043E" },
+  "&odash;": { "codepoints": [8861], "characters": "\u229D" },
+  "&odblac;": { "codepoints": [337], "characters": "\u0151" },
+  "&odiv;": { "codepoints": [10808], "characters": "\u2A38" },
+  "&odot;": { "codepoints": [8857], "characters": "\u2299" },
+  "&odsold;": { "codepoints": [10684], "characters": "\u29BC" },
+  "&oelig;": { "codepoints": [339], "characters": "\u0153" },
+  "&ofcir;": { "codepoints": [10687], "characters": "\u29BF" },
+  "&ofr;": { "codepoints": [120108], "characters": "\uD835\uDD2C" },
+  "&ogon;": { "codepoints": [731], "characters": "\u02DB" },
+  "&ograve": { "codepoints": [242], "characters": "\u00F2" },
+  "&ograve;": { "codepoints": [242], "characters": "\u00F2" },
+  "&ogt;": { "codepoints": [10689], "characters": "\u29C1" },
+  "&ohbar;": { "codepoints": [10677], "characters": "\u29B5" },
+  "&ohm;": { "codepoints": [937], "characters": "\u03A9" },
+  "&oint;": { "codepoints": [8750], "characters": "\u222E" },
+  "&olarr;": { "codepoints": [8634], "characters": "\u21BA" },
+  "&olcir;": { "codepoints": [10686], "characters": "\u29BE" },
+  "&olcross;": { "codepoints": [10683], "characters": "\u29BB" },
+  "&oline;": { "codepoints": [8254], "characters": "\u203E" },
+  "&olt;": { "codepoints": [10688], "characters": "\u29C0" },
+  "&omacr;": { "codepoints": [333], "characters": "\u014D" },
+  "&omega;": { "codepoints": [969], "characters": "\u03C9" },
+  "&omicron;": { "codepoints": [959], "characters": "\u03BF" },
+  "&omid;": { "codepoints": [10678], "characters": "\u29B6" },
+  "&ominus;": { "codepoints": [8854], "characters": "\u2296" },
+  "&oopf;": { "codepoints": [120160], "characters": "\uD835\uDD60" },
+  "&opar;": { "codepoints": [10679], "characters": "\u29B7" },
+  "&operp;": { "codepoints": [10681], "characters": "\u29B9" },
+  "&oplus;": { "codepoints": [8853], "characters": "\u2295" },
+  "&or;": { "codepoints": [8744], "characters": "\u2228" },
+  "&orarr;": { "codepoints": [8635], "characters": "\u21BB" },
+  "&ord;": { "codepoints": [10845], "characters": "\u2A5D" },
+  "&order;": { "codepoints": [8500], "characters": "\u2134" },
+  "&orderof;": { "codepoints": [8500], "characters": "\u2134" },
+  "&ordf": { "codepoints": [170], "characters": "\u00AA" },
+  "&ordf;": { "codepoints": [170], "characters": "\u00AA" },
+  "&ordm": { "codepoints": [186], "characters": "\u00BA" },
+  "&ordm;": { "codepoints": [186], "characters": "\u00BA" },
+  "&origof;": { "codepoints": [8886], "characters": "\u22B6" },
+  "&oror;": { "codepoints": [10838], "characters": "\u2A56" },
+  "&orslope;": { "codepoints": [10839], "characters": "\u2A57" },
+  "&orv;": { "codepoints": [10843], "characters": "\u2A5B" },
+  "&oscr;": { "codepoints": [8500], "characters": "\u2134" },
+  "&oslash": { "codepoints": [248], "characters": "\u00F8" },
+  "&oslash;": { "codepoints": [248], "characters": "\u00F8" },
+  "&osol;": { "codepoints": [8856], "characters": "\u2298" },
+  "&otilde": { "codepoints": [245], "characters": "\u00F5" },
+  "&otilde;": { "codepoints": [245], "characters": "\u00F5" },
+  "&otimes;": { "codepoints": [8855], "characters": "\u2297" },
+  "&otimesas;": { "codepoints": [10806], "characters": "\u2A36" },
+  "&ouml": { "codepoints": [246], "characters": "\u00F6" },
+  "&ouml;": { "codepoints": [246], "characters": "\u00F6" },
+  "&ovbar;": { "codepoints": [9021], "characters": "\u233D" },
+  "&par;": { "codepoints": [8741], "characters": "\u2225" },
+  "&para": { "codepoints": [182], "characters": "\u00B6" },
+  "&para;": { "codepoints": [182], "characters": "\u00B6" },
+  "&parallel;": { "codepoints": [8741], "characters": "\u2225" },
+  "&parsim;": { "codepoints": [10995], "characters": "\u2AF3" },
+  "&parsl;": { "codepoints": [11005], "characters": "\u2AFD" },
+  "&part;": { "codepoints": [8706], "characters": "\u2202" },
+  "&pcy;": { "codepoints": [1087], "characters": "\u043F" },
+  "&percnt;": { "codepoints": [37], "characters": "\u0025" },
+  "&period;": { "codepoints": [46], "characters": "\u002E" },
+  "&permil;": { "codepoints": [8240], "characters": "\u2030" },
+  "&perp;": { "codepoints": [8869], "characters": "\u22A5" },
+  "&pertenk;": { "codepoints": [8241], "characters": "\u2031" },
+  "&pfr;": { "codepoints": [120109], "characters": "\uD835\uDD2D" },
+  "&phi;": { "codepoints": [966], "characters": "\u03C6" },
+  "&phiv;": { "codepoints": [981], "characters": "\u03D5" },
+  "&phmmat;": { "codepoints": [8499], "characters": "\u2133" },
+  "&phone;": { "codepoints": [9742], "characters": "\u260E" },
+  "&pi;": { "codepoints": [960], "characters": "\u03C0" },
+  "&pitchfork;": { "codepoints": [8916], "characters": "\u22D4" },
+  "&piv;": { "codepoints": [982], "characters": "\u03D6" },
+  "&planck;": { "codepoints": [8463], "characters": "\u210F" },
+  "&planckh;": { "codepoints": [8462], "characters": "\u210E" },
+  "&plankv;": { "codepoints": [8463], "characters": "\u210F" },
+  "&plus;": { "codepoints": [43], "characters": "\u002B" },
+  "&plusacir;": { "codepoints": [10787], "characters": "\u2A23" },
+  "&plusb;": { "codepoints": [8862], "characters": "\u229E" },
+  "&pluscir;": { "codepoints": [10786], "characters": "\u2A22" },
+  "&plusdo;": { "codepoints": [8724], "characters": "\u2214" },
+  "&plusdu;": { "codepoints": [10789], "characters": "\u2A25" },
+  "&pluse;": { "codepoints": [10866], "characters": "\u2A72" },
+  "&plusmn": { "codepoints": [177], "characters": "\u00B1" },
+  "&plusmn;": { "codepoints": [177], "characters": "\u00B1" },
+  "&plussim;": { "codepoints": [10790], "characters": "\u2A26" },
+  "&plustwo;": { "codepoints": [10791], "characters": "\u2A27" },
+  "&pm;": { "codepoints": [177], "characters": "\u00B1" },
+  "&pointint;": { "codepoints": [10773], "characters": "\u2A15" },
+  "&popf;": { "codepoints": [120161], "characters": "\uD835\uDD61" },
+  "&pound": { "codepoints": [163], "characters": "\u00A3" },
+  "&pound;": { "codepoints": [163], "characters": "\u00A3" },
+  "&pr;": { "codepoints": [8826], "characters": "\u227A" },
+  "&prE;": { "codepoints": [10931], "characters": "\u2AB3" },
+  "&prap;": { "codepoints": [10935], "characters": "\u2AB7" },
+  "&prcue;": { "codepoints": [8828], "characters": "\u227C" },
+  "&pre;": { "codepoints": [10927], "characters": "\u2AAF" },
+  "&prec;": { "codepoints": [8826], "characters": "\u227A" },
+  "&precapprox;": { "codepoints": [10935], "characters": "\u2AB7" },
+  "&preccurlyeq;": { "codepoints": [8828], "characters": "\u227C" },
+  "&preceq;": { "codepoints": [10927], "characters": "\u2AAF" },
+  "&precnapprox;": { "codepoints": [10937], "characters": "\u2AB9" },
+  "&precneqq;": { "codepoints": [10933], "characters": "\u2AB5" },
+  "&precnsim;": { "codepoints": [8936], "characters": "\u22E8" },
+  "&precsim;": { "codepoints": [8830], "characters": "\u227E" },
+  "&prime;": { "codepoints": [8242], "characters": "\u2032" },
+  "&primes;": { "codepoints": [8473], "characters": "\u2119" },
+  "&prnE;": { "codepoints": [10933], "characters": "\u2AB5" },
+  "&prnap;": { "codepoints": [10937], "characters": "\u2AB9" },
+  "&prnsim;": { "codepoints": [8936], "characters": "\u22E8" },
+  "&prod;": { "codepoints": [8719], "characters": "\u220F" },
+  "&profalar;": { "codepoints": [9006], "characters": "\u232E" },
+  "&profline;": { "codepoints": [8978], "characters": "\u2312" },
+  "&profsurf;": { "codepoints": [8979], "characters": "\u2313" },
+  "&prop;": { "codepoints": [8733], "characters": "\u221D" },
+  "&propto;": { "codepoints": [8733], "characters": "\u221D" },
+  "&prsim;": { "codepoints": [8830], "characters": "\u227E" },
+  "&prurel;": { "codepoints": [8880], "characters": "\u22B0" },
+  "&pscr;": { "codepoints": [120005], "characters": "\uD835\uDCC5" },
+  "&psi;": { "codepoints": [968], "characters": "\u03C8" },
+  "&puncsp;": { "codepoints": [8200], "characters": "\u2008" },
+  "&qfr;": { "codepoints": [120110], "characters": "\uD835\uDD2E" },
+  "&qint;": { "codepoints": [10764], "characters": "\u2A0C" },
+  "&qopf;": { "codepoints": [120162], "characters": "\uD835\uDD62" },
+  "&qprime;": { "codepoints": [8279], "characters": "\u2057" },
+  "&qscr;": { "codepoints": [120006], "characters": "\uD835\uDCC6" },
+  "&quaternions;": { "codepoints": [8461], "characters": "\u210D" },
+  "&quatint;": { "codepoints": [10774], "characters": "\u2A16" },
+  "&quest;": { "codepoints": [63], "characters": "\u003F" },
+  "&questeq;": { "codepoints": [8799], "characters": "\u225F" },
+  "&quot": { "codepoints": [34], "characters": "\u0022" },
+  "&quot;": { "codepoints": [34], "characters": "\u0022" },
+  "&rAarr;": { "codepoints": [8667], "characters": "\u21DB" },
+  "&rArr;": { "codepoints": [8658], "characters": "\u21D2" },
+  "&rAtail;": { "codepoints": [10524], "characters": "\u291C" },
+  "&rBarr;": { "codepoints": [10511], "characters": "\u290F" },
+  "&rHar;": { "codepoints": [10596], "characters": "\u2964" },
+  "&race;": { "codepoints": [8765, 817], "characters": "\u223D\u0331" },
+  "&racute;": { "codepoints": [341], "characters": "\u0155" },
+  "&radic;": { "codepoints": [8730], "characters": "\u221A" },
+  "&raemptyv;": { "codepoints": [10675], "characters": "\u29B3" },
+  "&rang;": { "codepoints": [10217], "characters": "\u27E9" },
+  "&rangd;": { "codepoints": [10642], "characters": "\u2992" },
+  "&range;": { "codepoints": [10661], "characters": "\u29A5" },
+  "&rangle;": { "codepoints": [10217], "characters": "\u27E9" },
+  "&raquo": { "codepoints": [187], "characters": "\u00BB" },
+  "&raquo;": { "codepoints": [187], "characters": "\u00BB" },
+  "&rarr;": { "codepoints": [8594], "characters": "\u2192" },
+  "&rarrap;": { "codepoints": [10613], "characters": "\u2975" },
+  "&rarrb;": { "codepoints": [8677], "characters": "\u21E5" },
+  "&rarrbfs;": { "codepoints": [10528], "characters": "\u2920" },
+  "&rarrc;": { "codepoints": [10547], "characters": "\u2933" },
+  "&rarrfs;": { "codepoints": [10526], "characters": "\u291E" },
+  "&rarrhk;": { "codepoints": [8618], "characters": "\u21AA" },
+  "&rarrlp;": { "codepoints": [8620], "characters": "\u21AC" },
+  "&rarrpl;": { "codepoints": [10565], "characters": "\u2945" },
+  "&rarrsim;": { "codepoints": [10612], "characters": "\u2974" },
+  "&rarrtl;": { "codepoints": [8611], "characters": "\u21A3" },
+  "&rarrw;": { "codepoints": [8605], "characters": "\u219D" },
+  "&ratail;": { "codepoints": [10522], "characters": "\u291A" },
+  "&ratio;": { "codepoints": [8758], "characters": "\u2236" },
+  "&rationals;": { "codepoints": [8474], "characters": "\u211A" },
+  "&rbarr;": { "codepoints": [10509], "characters": "\u290D" },
+  "&rbbrk;": { "codepoints": [10099], "characters": "\u2773" },
+  "&rbrace;": { "codepoints": [125], "characters": "\u007D" },
+  "&rbrack;": { "codepoints": [93], "characters": "\u005D" },
+  "&rbrke;": { "codepoints": [10636], "characters": "\u298C" },
+  "&rbrksld;": { "codepoints": [10638], "characters": "\u298E" },
+  "&rbrkslu;": { "codepoints": [10640], "characters": "\u2990" },
+  "&rcaron;": { "codepoints": [345], "characters": "\u0159" },
+  "&rcedil;": { "codepoints": [343], "characters": "\u0157" },
+  "&rceil;": { "codepoints": [8969], "characters": "\u2309" },
+  "&rcub;": { "codepoints": [125], "characters": "\u007D" },
+  "&rcy;": { "codepoints": [1088], "characters": "\u0440" },
+  "&rdca;": { "codepoints": [10551], "characters": "\u2937" },
+  "&rdldhar;": { "codepoints": [10601], "characters": "\u2969" },
+  "&rdquo;": { "codepoints": [8221], "characters": "\u201D" },
+  "&rdquor;": { "codepoints": [8221], "characters": "\u201D" },
+  "&rdsh;": { "codepoints": [8627], "characters": "\u21B3" },
+  "&real;": { "codepoints": [8476], "characters": "\u211C" },
+  "&realine;": { "codepoints": [8475], "characters": "\u211B" },
+  "&realpart;": { "codepoints": [8476], "characters": "\u211C" },
+  "&reals;": { "codepoints": [8477], "characters": "\u211D" },
+  "&rect;": { "codepoints": [9645], "characters": "\u25AD" },
+  "&reg": { "codepoints": [174], "characters": "\u00AE" },
+  "&reg;": { "codepoints": [174], "characters": "\u00AE" },
+  "&rfisht;": { "codepoints": [10621], "characters": "\u297D" },
+  "&rfloor;": { "codepoints": [8971], "characters": "\u230B" },
+  "&rfr;": { "codepoints": [120111], "characters": "\uD835\uDD2F" },
+  "&rhard;": { "codepoints": [8641], "characters": "\u21C1" },
+  "&rharu;": { "codepoints": [8640], "characters": "\u21C0" },
+  "&rharul;": { "codepoints": [10604], "characters": "\u296C" },
+  "&rho;": { "codepoints": [961], "characters": "\u03C1" },
+  "&rhov;": { "codepoints": [1009], "characters": "\u03F1" },
+  "&rightarrow;": { "codepoints": [8594], "characters": "\u2192" },
+  "&rightarrowtail;": { "codepoints": [8611], "characters": "\u21A3" },
+  "&rightharpoondown;": { "codepoints": [8641], "characters": "\u21C1" },
+  "&rightharpoonup;": { "codepoints": [8640], "characters": "\u21C0" },
+  "&rightleftarrows;": { "codepoints": [8644], "characters": "\u21C4" },
+  "&rightleftharpoons;": { "codepoints": [8652], "characters": "\u21CC" },
+  "&rightrightarrows;": { "codepoints": [8649], "characters": "\u21C9" },
+  "&rightsquigarrow;": { "codepoints": [8605], "characters": "\u219D" },
+  "&rightthreetimes;": { "codepoints": [8908], "characters": "\u22CC" },
+  "&ring;": { "codepoints": [730], "characters": "\u02DA" },
+  "&risingdotseq;": { "codepoints": [8787], "characters": "\u2253" },
+  "&rlarr;": { "codepoints": [8644], "characters": "\u21C4" },
+  "&rlhar;": { "codepoints": [8652], "characters": "\u21CC" },
+  "&rlm;": { "codepoints": [8207], "characters": "\u200F" },
+  "&rmoust;": { "codepoints": [9137], "characters": "\u23B1" },
+  "&rmoustache;": { "codepoints": [9137], "characters": "\u23B1" },
+  "&rnmid;": { "codepoints": [10990], "characters": "\u2AEE" },
+  "&roang;": { "codepoints": [10221], "characters": "\u27ED" },
+  "&roarr;": { "codepoints": [8702], "characters": "\u21FE" },
+  "&robrk;": { "codepoints": [10215], "characters": "\u27E7" },
+  "&ropar;": { "codepoints": [10630], "characters": "\u2986" },
+  "&ropf;": { "codepoints": [120163], "characters": "\uD835\uDD63" },
+  "&roplus;": { "codepoints": [10798], "characters": "\u2A2E" },
+  "&rotimes;": { "codepoints": [10805], "characters": "\u2A35" },
+  "&rpar;": { "codepoints": [41], "characters": "\u0029" },
+  "&rpargt;": { "codepoints": [10644], "characters": "\u2994" },
+  "&rppolint;": { "codepoints": [10770], "characters": "\u2A12" },
+  "&rrarr;": { "codepoints": [8649], "characters": "\u21C9" },
+  "&rsaquo;": { "codepoints": [8250], "characters": "\u203A" },
+  "&rscr;": { "codepoints": [120007], "characters": "\uD835\uDCC7" },
+  "&rsh;": { "codepoints": [8625], "characters": "\u21B1" },
+  "&rsqb;": { "codepoints": [93], "characters": "\u005D" },
+  "&rsquo;": { "codepoints": [8217], "characters": "\u2019" },
+  "&rsquor;": { "codepoints": [8217], "characters": "\u2019" },
+  "&rthree;": { "codepoints": [8908], "characters": "\u22CC" },
+  "&rtimes;": { "codepoints": [8906], "characters": "\u22CA" },
+  "&rtri;": { "codepoints": [9657], "characters": "\u25B9" },
+  "&rtrie;": { "codepoints": [8885], "characters": "\u22B5" },
+  "&rtrif;": { "codepoints": [9656], "characters": "\u25B8" },
+  "&rtriltri;": { "codepoints": [10702], "characters": "\u29CE" },
+  "&ruluhar;": { "codepoints": [10600], "characters": "\u2968" },
+  "&rx;": { "codepoints": [8478], "characters": "\u211E" },
+  "&sacute;": { "codepoints": [347], "characters": "\u015B" },
+  "&sbquo;": { "codepoints": [8218], "characters": "\u201A" },
+  "&sc;": { "codepoints": [8827], "characters": "\u227B" },
+  "&scE;": { "codepoints": [10932], "characters": "\u2AB4" },
+  "&scap;": { "codepoints": [10936], "characters": "\u2AB8" },
+  "&scaron;": { "codepoints": [353], "characters": "\u0161" },
+  "&sccue;": { "codepoints": [8829], "characters": "\u227D" },
+  "&sce;": { "codepoints": [10928], "characters": "\u2AB0" },
+  "&scedil;": { "codepoints": [351], "characters": "\u015F" },
+  "&scirc;": { "codepoints": [349], "characters": "\u015D" },
+  "&scnE;": { "codepoints": [10934], "characters": "\u2AB6" },
+  "&scnap;": { "codepoints": [10938], "characters": "\u2ABA" },
+  "&scnsim;": { "codepoints": [8937], "characters": "\u22E9" },
+  "&scpolint;": { "codepoints": [10771], "characters": "\u2A13" },
+  "&scsim;": { "codepoints": [8831], "characters": "\u227F" },
+  "&scy;": { "codepoints": [1089], "characters": "\u0441" },
+  "&sdot;": { "codepoints": [8901], "characters": "\u22C5" },
+  "&sdotb;": { "codepoints": [8865], "characters": "\u22A1" },
+  "&sdote;": { "codepoints": [10854], "characters": "\u2A66" },
+  "&seArr;": { "codepoints": [8664], "characters": "\u21D8" },
+  "&searhk;": { "codepoints": [10533], "characters": "\u2925" },
+  "&searr;": { "codepoints": [8600], "characters": "\u2198" },
+  "&searrow;": { "codepoints": [8600], "characters": "\u2198" },
+  "&sect": { "codepoints": [167], "characters": "\u00A7" },
+  "&sect;": { "codepoints": [167], "characters": "\u00A7" },
+  "&semi;": { "codepoints": [59], "characters": "\u003B" },
+  "&seswar;": { "codepoints": [10537], "characters": "\u2929" },
+  "&setminus;": { "codepoints": [8726], "characters": "\u2216" },
+  "&setmn;": { "codepoints": [8726], "characters": "\u2216" },
+  "&sext;": { "codepoints": [10038], "characters": "\u2736" },
+  "&sfr;": { "codepoints": [120112], "characters": "\uD835\uDD30" },
+  "&sfrown;": { "codepoints": [8994], "characters": "\u2322" },
+  "&sharp;": { "codepoints": [9839], "characters": "\u266F" },
+  "&shchcy;": { "codepoints": [1097], "characters": "\u0449" },
+  "&shcy;": { "codepoints": [1096], "characters": "\u0448" },
+  "&shortmid;": { "codepoints": [8739], "characters": "\u2223" },
+  "&shortparallel;": { "codepoints": [8741], "characters": "\u2225" },
+  "&shy": { "codepoints": [173], "characters": "\u00AD" },
+  "&shy;": { "codepoints": [173], "characters": "\u00AD" },
+  "&sigma;": { "codepoints": [963], "characters": "\u03C3" },
+  "&sigmaf;": { "codepoints": [962], "characters": "\u03C2" },
+  "&sigmav;": { "codepoints": [962], "characters": "\u03C2" },
+  "&sim;": { "codepoints": [8764], "characters": "\u223C" },
+  "&simdot;": { "codepoints": [10858], "characters": "\u2A6A" },
+  "&sime;": { "codepoints": [8771], "characters": "\u2243" },
+  "&simeq;": { "codepoints": [8771], "characters": "\u2243" },
+  "&simg;": { "codepoints": [10910], "characters": "\u2A9E" },
+  "&simgE;": { "codepoints": [10912], "characters": "\u2AA0" },
+  "&siml;": { "codepoints": [10909], "characters": "\u2A9D" },
+  "&simlE;": { "codepoints": [10911], "characters": "\u2A9F" },
+  "&simne;": { "codepoints": [8774], "characters": "\u2246" },
+  "&simplus;": { "codepoints": [10788], "characters": "\u2A24" },
+  "&simrarr;": { "codepoints": [10610], "characters": "\u2972" },
+  "&slarr;": { "codepoints": [8592], "characters": "\u2190" },
+  "&smallsetminus;": { "codepoints": [8726], "characters": "\u2216" },
+  "&smashp;": { "codepoints": [10803], "characters": "\u2A33" },
+  "&smeparsl;": { "codepoints": [10724], "characters": "\u29E4" },
+  "&smid;": { "codepoints": [8739], "characters": "\u2223" },
+  "&smile;": { "codepoints": [8995], "characters": "\u2323" },
+  "&smt;": { "codepoints": [10922], "characters": "\u2AAA" },
+  "&smte;": { "codepoints": [10924], "characters": "\u2AAC" },
+  "&smtes;": { "codepoints": [10924, 65024], "characters": "\u2AAC\uFE00" },
+  "&softcy;": { "codepoints": [1100], "characters": "\u044C" },
+  "&sol;": { "codepoints": [47], "characters": "\u002F" },
+  "&solb;": { "codepoints": [10692], "characters": "\u29C4" },
+  "&solbar;": { "codepoints": [9023], "characters": "\u233F" },
+  "&sopf;": { "codepoints": [120164], "characters": "\uD835\uDD64" },
+  "&spades;": { "codepoints": [9824], "characters": "\u2660" },
+  "&spadesuit;": { "codepoints": [9824], "characters": "\u2660" },
+  "&spar;": { "codepoints": [8741], "characters": "\u2225" },
+  "&sqcap;": { "codepoints": [8851], "characters": "\u2293" },
+  "&sqcaps;": { "codepoints": [8851, 65024], "characters": "\u2293\uFE00" },
+  "&sqcup;": { "codepoints": [8852], "characters": "\u2294" },
+  "&sqcups;": { "codepoints": [8852, 65024], "characters": "\u2294\uFE00" },
+  "&sqsub;": { "codepoints": [8847], "characters": "\u228F" },
+  "&sqsube;": { "codepoints": [8849], "characters": "\u2291" },
+  "&sqsubset;": { "codepoints": [8847], "characters": "\u228F" },
+  "&sqsubseteq;": { "codepoints": [8849], "characters": "\u2291" },
+  "&sqsup;": { "codepoints": [8848], "characters": "\u2290" },
+  "&sqsupe;": { "codepoints": [8850], "characters": "\u2292" },
+  "&sqsupset;": { "codepoints": [8848], "characters": "\u2290" },
+  "&sqsupseteq;": { "codepoints": [8850], "characters": "\u2292" },
+  "&squ;": { "codepoints": [9633], "characters": "\u25A1" },
+  "&square;": { "codepoints": [9633], "characters": "\u25A1" },
+  "&squarf;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&squf;": { "codepoints": [9642], "characters": "\u25AA" },
+  "&srarr;": { "codepoints": [8594], "characters": "\u2192" },
+  "&sscr;": { "codepoints": [120008], "characters": "\uD835\uDCC8" },
+  "&ssetmn;": { "codepoints": [8726], "characters": "\u2216" },
+  "&ssmile;": { "codepoints": [8995], "characters": "\u2323" },
+  "&sstarf;": { "codepoints": [8902], "characters": "\u22C6" },
+  "&star;": { "codepoints": [9734], "characters": "\u2606" },
+  "&starf;": { "codepoints": [9733], "characters": "\u2605" },
+  "&straightepsilon;": { "codepoints": [1013], "characters": "\u03F5" },
+  "&straightphi;": { "codepoints": [981], "characters": "\u03D5" },
+  "&strns;": { "codepoints": [175], "characters": "\u00AF" },
+  "&sub;": { "codepoints": [8834], "characters": "\u2282" },
+  "&subE;": { "codepoints": [10949], "characters": "\u2AC5" },
+  "&subdot;": { "codepoints": [10941], "characters": "\u2ABD" },
+  "&sube;": { "codepoints": [8838], "characters": "\u2286" },
+  "&subedot;": { "codepoints": [10947], "characters": "\u2AC3" },
+  "&submult;": { "codepoints": [10945], "characters": "\u2AC1" },
+  "&subnE;": { "codepoints": [10955], "characters": "\u2ACB" },
+  "&subne;": { "codepoints": [8842], "characters": "\u228A" },
+  "&subplus;": { "codepoints": [10943], "characters": "\u2ABF" },
+  "&subrarr;": { "codepoints": [10617], "characters": "\u2979" },
+  "&subset;": { "codepoints": [8834], "characters": "\u2282" },
+  "&subseteq;": { "codepoints": [8838], "characters": "\u2286" },
+  "&subseteqq;": { "codepoints": [10949], "characters": "\u2AC5" },
+  "&subsetneq;": { "codepoints": [8842], "characters": "\u228A" },
+  "&subsetneqq;": { "codepoints": [10955], "characters": "\u2ACB" },
+  "&subsim;": { "codepoints": [10951], "characters": "\u2AC7" },
+  "&subsub;": { "codepoints": [10965], "characters": "\u2AD5" },
+  "&subsup;": { "codepoints": [10963], "characters": "\u2AD3" },
+  "&succ;": { "codepoints": [8827], "characters": "\u227B" },
+  "&succapprox;": { "codepoints": [10936], "characters": "\u2AB8" },
+  "&succcurlyeq;": { "codepoints": [8829], "characters": "\u227D" },
+  "&succeq;": { "codepoints": [10928], "characters": "\u2AB0" },
+  "&succnapprox;": { "codepoints": [10938], "characters": "\u2ABA" },
+  "&succneqq;": { "codepoints": [10934], "characters": "\u2AB6" },
+  "&succnsim;": { "codepoints": [8937], "characters": "\u22E9" },
+  "&succsim;": { "codepoints": [8831], "characters": "\u227F" },
+  "&sum;": { "codepoints": [8721], "characters": "\u2211" },
+  "&sung;": { "codepoints": [9834], "characters": "\u266A" },
+  "&sup1": { "codepoints": [185], "characters": "\u00B9" },
+  "&sup1;": { "codepoints": [185], "characters": "\u00B9" },
+  "&sup2": { "codepoints": [178], "characters": "\u00B2" },
+  "&sup2;": { "codepoints": [178], "characters": "\u00B2" },
+  "&sup3": { "codepoints": [179], "characters": "\u00B3" },
+  "&sup3;": { "codepoints": [179], "characters": "\u00B3" },
+  "&sup;": { "codepoints": [8835], "characters": "\u2283" },
+  "&supE;": { "codepoints": [10950], "characters": "\u2AC6" },
+  "&supdot;": { "codepoints": [10942], "characters": "\u2ABE" },
+  "&supdsub;": { "codepoints": [10968], "characters": "\u2AD8" },
+  "&supe;": { "codepoints": [8839], "characters": "\u2287" },
+  "&supedot;": { "codepoints": [10948], "characters": "\u2AC4" },
+  "&suphsol;": { "codepoints": [10185], "characters": "\u27C9" },
+  "&suphsub;": { "codepoints": [10967], "characters": "\u2AD7" },
+  "&suplarr;": { "codepoints": [10619], "characters": "\u297B" },
+  "&supmult;": { "codepoints": [10946], "characters": "\u2AC2" },
+  "&supnE;": { "codepoints": [10956], "characters": "\u2ACC" },
+  "&supne;": { "codepoints": [8843], "characters": "\u228B" },
+  "&supplus;": { "codepoints": [10944], "characters": "\u2AC0" },
+  "&supset;": { "codepoints": [8835], "characters": "\u2283" },
+  "&supseteq;": { "codepoints": [8839], "characters": "\u2287" },
+  "&supseteqq;": { "codepoints": [10950], "characters": "\u2AC6" },
+  "&supsetneq;": { "codepoints": [8843], "characters": "\u228B" },
+  "&supsetneqq;": { "codepoints": [10956], "characters": "\u2ACC" },
+  "&supsim;": { "codepoints": [10952], "characters": "\u2AC8" },
+  "&supsub;": { "codepoints": [10964], "characters": "\u2AD4" },
+  "&supsup;": { "codepoints": [10966], "characters": "\u2AD6" },
+  "&swArr;": { "codepoints": [8665], "characters": "\u21D9" },
+  "&swarhk;": { "codepoints": [10534], "characters": "\u2926" },
+  "&swarr;": { "codepoints": [8601], "characters": "\u2199" },
+  "&swarrow;": { "codepoints": [8601], "characters": "\u2199" },
+  "&swnwar;": { "codepoints": [10538], "characters": "\u292A" },
+  "&szlig": { "codepoints": [223], "characters": "\u00DF" },
+  "&szlig;": { "codepoints": [223], "characters": "\u00DF" },
+  "&target;": { "codepoints": [8982], "characters": "\u2316" },
+  "&tau;": { "codepoints": [964], "characters": "\u03C4" },
+  "&tbrk;": { "codepoints": [9140], "characters": "\u23B4" },
+  "&tcaron;": { "codepoints": [357], "characters": "\u0165" },
+  "&tcedil;": { "codepoints": [355], "characters": "\u0163" },
+  "&tcy;": { "codepoints": [1090], "characters": "\u0442" },
+  "&tdot;": { "codepoints": [8411], "characters": "\u20DB" },
+  "&telrec;": { "codepoints": [8981], "characters": "\u2315" },
+  "&tfr;": { "codepoints": [120113], "characters": "\uD835\uDD31" },
+  "&there4;": { "codepoints": [8756], "characters": "\u2234" },
+  "&therefore;": { "codepoints": [8756], "characters": "\u2234" },
+  "&theta;": { "codepoints": [952], "characters": "\u03B8" },
+  "&thetasym;": { "codepoints": [977], "characters": "\u03D1" },
+  "&thetav;": { "codepoints": [977], "characters": "\u03D1" },
+  "&thickapprox;": { "codepoints": [8776], "characters": "\u2248" },
+  "&thicksim;": { "codepoints": [8764], "characters": "\u223C" },
+  "&thinsp;": { "codepoints": [8201], "characters": "\u2009" },
+  "&thkap;": { "codepoints": [8776], "characters": "\u2248" },
+  "&thksim;": { "codepoints": [8764], "characters": "\u223C" },
+  "&thorn": { "codepoints": [254], "characters": "\u00FE" },
+  "&thorn;": { "codepoints": [254], "characters": "\u00FE" },
+  "&tilde;": { "codepoints": [732], "characters": "\u02DC" },
+  "&times": { "codepoints": [215], "characters": "\u00D7" },
+  "&times;": { "codepoints": [215], "characters": "\u00D7" },
+  "&timesb;": { "codepoints": [8864], "characters": "\u22A0" },
+  "&timesbar;": { "codepoints": [10801], "characters": "\u2A31" },
+  "&timesd;": { "codepoints": [10800], "characters": "\u2A30" },
+  "&tint;": { "codepoints": [8749], "characters": "\u222D" },
+  "&toea;": { "codepoints": [10536], "characters": "\u2928" },
+  "&top;": { "codepoints": [8868], "characters": "\u22A4" },
+  "&topbot;": { "codepoints": [9014], "characters": "\u2336" },
+  "&topcir;": { "codepoints": [10993], "characters": "\u2AF1" },
+  "&topf;": { "codepoints": [120165], "characters": "\uD835\uDD65" },
+  "&topfork;": { "codepoints": [10970], "characters": "\u2ADA" },
+  "&tosa;": { "codepoints": [10537], "characters": "\u2929" },
+  "&tprime;": { "codepoints": [8244], "characters": "\u2034" },
+  "&trade;": { "codepoints": [8482], "characters": "\u2122" },
+  "&triangle;": { "codepoints": [9653], "characters": "\u25B5" },
+  "&triangledown;": { "codepoints": [9663], "characters": "\u25BF" },
+  "&triangleleft;": { "codepoints": [9667], "characters": "\u25C3" },
+  "&trianglelefteq;": { "codepoints": [8884], "characters": "\u22B4" },
+  "&triangleq;": { "codepoints": [8796], "characters": "\u225C" },
+  "&triangleright;": { "codepoints": [9657], "characters": "\u25B9" },
+  "&trianglerighteq;": { "codepoints": [8885], "characters": "\u22B5" },
+  "&tridot;": { "codepoints": [9708], "characters": "\u25EC" },
+  "&trie;": { "codepoints": [8796], "characters": "\u225C" },
+  "&triminus;": { "codepoints": [10810], "characters": "\u2A3A" },
+  "&triplus;": { "codepoints": [10809], "characters": "\u2A39" },
+  "&trisb;": { "codepoints": [10701], "characters": "\u29CD" },
+  "&tritime;": { "codepoints": [10811], "characters": "\u2A3B" },
+  "&trpezium;": { "codepoints": [9186], "characters": "\u23E2" },
+  "&tscr;": { "codepoints": [120009], "characters": "\uD835\uDCC9" },
+  "&tscy;": { "codepoints": [1094], "characters": "\u0446" },
+  "&tshcy;": { "codepoints": [1115], "characters": "\u045B" },
+  "&tstrok;": { "codepoints": [359], "characters": "\u0167" },
+  "&twixt;": { "codepoints": [8812], "characters": "\u226C" },
+  "&twoheadleftarrow;": { "codepoints": [8606], "characters": "\u219E" },
+  "&twoheadrightarrow;": { "codepoints": [8608], "characters": "\u21A0" },
+  "&uArr;": { "codepoints": [8657], "characters": "\u21D1" },
+  "&uHar;": { "codepoints": [10595], "characters": "\u2963" },
+  "&uacute": { "codepoints": [250], "characters": "\u00FA" },
+  "&uacute;": { "codepoints": [250], "characters": "\u00FA" },
+  "&uarr;": { "codepoints": [8593], "characters": "\u2191" },
+  "&ubrcy;": { "codepoints": [1118], "characters": "\u045E" },
+  "&ubreve;": { "codepoints": [365], "characters": "\u016D" },
+  "&ucirc": { "codepoints": [251], "characters": "\u00FB" },
+  "&ucirc;": { "codepoints": [251], "characters": "\u00FB" },
+  "&ucy;": { "codepoints": [1091], "characters": "\u0443" },
+  "&udarr;": { "codepoints": [8645], "characters": "\u21C5" },
+  "&udblac;": { "codepoints": [369], "characters": "\u0171" },
+  "&udhar;": { "codepoints": [10606], "characters": "\u296E" },
+  "&ufisht;": { "codepoints": [10622], "characters": "\u297E" },
+  "&ufr;": { "codepoints": [120114], "characters": "\uD835\uDD32" },
+  "&ugrave": { "codepoints": [249], "characters": "\u00F9" },
+  "&ugrave;": { "codepoints": [249], "characters": "\u00F9" },
+  "&uharl;": { "codepoints": [8639], "characters": "\u21BF" },
+  "&uharr;": { "codepoints": [8638], "characters": "\u21BE" },
+  "&uhblk;": { "codepoints": [9600], "characters": "\u2580" },
+  "&ulcorn;": { "codepoints": [8988], "characters": "\u231C" },
+  "&ulcorner;": { "codepoints": [8988], "characters": "\u231C" },
+  "&ulcrop;": { "codepoints": [8975], "characters": "\u230F" },
+  "&ultri;": { "codepoints": [9720], "characters": "\u25F8" },
+  "&umacr;": { "codepoints": [363], "characters": "\u016B" },
+  "&uml": { "codepoints": [168], "characters": "\u00A8" },
+  "&uml;": { "codepoints": [168], "characters": "\u00A8" },
+  "&uogon;": { "codepoints": [371], "characters": "\u0173" },
+  "&uopf;": { "codepoints": [120166], "characters": "\uD835\uDD66" },
+  "&uparrow;": { "codepoints": [8593], "characters": "\u2191" },
+  "&updownarrow;": { "codepoints": [8597], "characters": "\u2195" },
+  "&upharpoonleft;": { "codepoints": [8639], "characters": "\u21BF" },
+  "&upharpoonright;": { "codepoints": [8638], "characters": "\u21BE" },
+  "&uplus;": { "codepoints": [8846], "characters": "\u228E" },
+  "&upsi;": { "codepoints": [965], "characters": "\u03C5" },
+  "&upsih;": { "codepoints": [978], "characters": "\u03D2" },
+  "&upsilon;": { "codepoints": [965], "characters": "\u03C5" },
+  "&upuparrows;": { "codepoints": [8648], "characters": "\u21C8" },
+  "&urcorn;": { "codepoints": [8989], "characters": "\u231D" },
+  "&urcorner;": { "codepoints": [8989], "characters": "\u231D" },
+  "&urcrop;": { "codepoints": [8974], "characters": "\u230E" },
+  "&uring;": { "codepoints": [367], "characters": "\u016F" },
+  "&urtri;": { "codepoints": [9721], "characters": "\u25F9" },
+  "&uscr;": { "codepoints": [120010], "characters": "\uD835\uDCCA" },
+  "&utdot;": { "codepoints": [8944], "characters": "\u22F0" },
+  "&utilde;": { "codepoints": [361], "characters": "\u0169" },
+  "&utri;": { "codepoints": [9653], "characters": "\u25B5" },
+  "&utrif;": { "codepoints": [9652], "characters": "\u25B4" },
+  "&uuarr;": { "codepoints": [8648], "characters": "\u21C8" },
+  "&uuml": { "codepoints": [252], "characters": "\u00FC" },
+  "&uuml;": { "codepoints": [252], "characters": "\u00FC" },
+  "&uwangle;": { "codepoints": [10663], "characters": "\u29A7" },
+  "&vArr;": { "codepoints": [8661], "characters": "\u21D5" },
+  "&vBar;": { "codepoints": [10984], "characters": "\u2AE8" },
+  "&vBarv;": { "codepoints": [10985], "characters": "\u2AE9" },
+  "&vDash;": { "codepoints": [8872], "characters": "\u22A8" },
+  "&vangrt;": { "codepoints": [10652], "characters": "\u299C" },
+  "&varepsilon;": { "codepoints": [1013], "characters": "\u03F5" },
+  "&varkappa;": { "codepoints": [1008], "characters": "\u03F0" },
+  "&varnothing;": { "codepoints": [8709], "characters": "\u2205" },
+  "&varphi;": { "codepoints": [981], "characters": "\u03D5" },
+  "&varpi;": { "codepoints": [982], "characters": "\u03D6" },
+  "&varpropto;": { "codepoints": [8733], "characters": "\u221D" },
+  "&varr;": { "codepoints": [8597], "characters": "\u2195" },
+  "&varrho;": { "codepoints": [1009], "characters": "\u03F1" },
+  "&varsigma;": { "codepoints": [962], "characters": "\u03C2" },
+  "&varsubsetneq;": { "codepoints": [8842, 65024], "characters": "\u228A\uFE00" },
+  "&varsubsetneqq;": { "codepoints": [10955, 65024], "characters": "\u2ACB\uFE00" },
+  "&varsupsetneq;": { "codepoints": [8843, 65024], "characters": "\u228B\uFE00" },
+  "&varsupsetneqq;": { "codepoints": [10956, 65024], "characters": "\u2ACC\uFE00" },
+  "&vartheta;": { "codepoints": [977], "characters": "\u03D1" },
+  "&vartriangleleft;": { "codepoints": [8882], "characters": "\u22B2" },
+  "&vartriangleright;": { "codepoints": [8883], "characters": "\u22B3" },
+  "&vcy;": { "codepoints": [1074], "characters": "\u0432" },
+  "&vdash;": { "codepoints": [8866], "characters": "\u22A2" },
+  "&vee;": { "codepoints": [8744], "characters": "\u2228" },
+  "&veebar;": { "codepoints": [8891], "characters": "\u22BB" },
+  "&veeeq;": { "codepoints": [8794], "characters": "\u225A" },
+  "&vellip;": { "codepoints": [8942], "characters": "\u22EE" },
+  "&verbar;": { "codepoints": [124], "characters": "\u007C" },
+  "&vert;": { "codepoints": [124], "characters": "\u007C" },
+  "&vfr;": { "codepoints": [120115], "characters": "\uD835\uDD33" },
+  "&vltri;": { "codepoints": [8882], "characters": "\u22B2" },
+  "&vnsub;": { "codepoints": [8834, 8402], "characters": "\u2282\u20D2" },
+  "&vnsup;": { "codepoints": [8835, 8402], "characters": "\u2283\u20D2" },
+  "&vopf;": { "codepoints": [120167], "characters": "\uD835\uDD67" },
+  "&vprop;": { "codepoints": [8733], "characters": "\u221D" },
+  "&vrtri;": { "codepoints": [8883], "characters": "\u22B3" },
+  "&vscr;": { "codepoints": [120011], "characters": "\uD835\uDCCB" },
+  "&vsubnE;": { "codepoints": [10955, 65024], "characters": "\u2ACB\uFE00" },
+  "&vsubne;": { "codepoints": [8842, 65024], "characters": "\u228A\uFE00" },
+  "&vsupnE;": { "codepoints": [10956, 65024], "characters": "\u2ACC\uFE00" },
+  "&vsupne;": { "codepoints": [8843, 65024], "characters": "\u228B\uFE00" },
+  "&vzigzag;": { "codepoints": [10650], "characters": "\u299A" },
+  "&wcirc;": { "codepoints": [373], "characters": "\u0175" },
+  "&wedbar;": { "codepoints": [10847], "characters": "\u2A5F" },
+  "&wedge;": { "codepoints": [8743], "characters": "\u2227" },
+  "&wedgeq;": { "codepoints": [8793], "characters": "\u2259" },
+  "&weierp;": { "codepoints": [8472], "characters": "\u2118" },
+  "&wfr;": { "codepoints": [120116], "characters": "\uD835\uDD34" },
+  "&wopf;": { "codepoints": [120168], "characters": "\uD835\uDD68" },
+  "&wp;": { "codepoints": [8472], "characters": "\u2118" },
+  "&wr;": { "codepoints": [8768], "characters": "\u2240" },
+  "&wreath;": { "codepoints": [8768], "characters": "\u2240" },
+  "&wscr;": { "codepoints": [120012], "characters": "\uD835\uDCCC" },
+  "&xcap;": { "codepoints": [8898], "characters": "\u22C2" },
+  "&xcirc;": { "codepoints": [9711], "characters": "\u25EF" },
+  "&xcup;": { "codepoints": [8899], "characters": "\u22C3" },
+  "&xdtri;": { "codepoints": [9661], "characters": "\u25BD" },
+  "&xfr;": { "codepoints": [120117], "characters": "\uD835\uDD35" },
+  "&xhArr;": { "codepoints": [10234], "characters": "\u27FA" },
+  "&xharr;": { "codepoints": [10231], "characters": "\u27F7" },
+  "&xi;": { "codepoints": [958], "characters": "\u03BE" },
+  "&xlArr;": { "codepoints": [10232], "characters": "\u27F8" },
+  "&xlarr;": { "codepoints": [10229], "characters": "\u27F5" },
+  "&xmap;": { "codepoints": [10236], "characters": "\u27FC" },
+  "&xnis;": { "codepoints": [8955], "characters": "\u22FB" },
+  "&xodot;": { "codepoints": [10752], "characters": "\u2A00" },
+  "&xopf;": { "codepoints": [120169], "characters": "\uD835\uDD69" },
+  "&xoplus;": { "codepoints": [10753], "characters": "\u2A01" },
+  "&xotime;": { "codepoints": [10754], "characters": "\u2A02" },
+  "&xrArr;": { "codepoints": [10233], "characters": "\u27F9" },
+  "&xrarr;": { "codepoints": [10230], "characters": "\u27F6" },
+  "&xscr;": { "codepoints": [120013], "characters": "\uD835\uDCCD" },
+  "&xsqcup;": { "codepoints": [10758], "characters": "\u2A06" },
+  "&xuplus;": { "codepoints": [10756], "characters": "\u2A04" },
+  "&xutri;": { "codepoints": [9651], "characters": "\u25B3" },
+  "&xvee;": { "codepoints": [8897], "characters": "\u22C1" },
+  "&xwedge;": { "codepoints": [8896], "characters": "\u22C0" },
+  "&yacute": { "codepoints": [253], "characters": "\u00FD" },
+  "&yacute;": { "codepoints": [253], "characters": "\u00FD" },
+  "&yacy;": { "codepoints": [1103], "characters": "\u044F" },
+  "&ycirc;": { "codepoints": [375], "characters": "\u0177" },
+  "&ycy;": { "codepoints": [1099], "characters": "\u044B" },
+  "&yen": { "codepoints": [165], "characters": "\u00A5" },
+  "&yen;": { "codepoints": [165], "characters": "\u00A5" },
+  "&yfr;": { "codepoints": [120118], "characters": "\uD835\uDD36" },
+  "&yicy;": { "codepoints": [1111], "characters": "\u0457" },
+  "&yopf;": { "codepoints": [120170], "characters": "\uD835\uDD6A" },
+  "&yscr;": { "codepoints": [120014], "characters": "\uD835\uDCCE" },
+  "&yucy;": { "codepoints": [1102], "characters": "\u044E" },
+  "&yuml": { "codepoints": [255], "characters": "\u00FF" },
+  "&yuml;": { "codepoints": [255], "characters": "\u00FF" },
+  "&zacute;": { "codepoints": [378], "characters": "\u017A" },
+  "&zcaron;": { "codepoints": [382], "characters": "\u017E" },
+  "&zcy;": { "codepoints": [1079], "characters": "\u0437" },
+  "&zdot;": { "codepoints": [380], "characters": "\u017C" },
+  "&zeetrf;": { "codepoints": [8488], "characters": "\u2128" },
+  "&zeta;": { "codepoints": [950], "characters": "\u03B6" },
+  "&zfr;": { "codepoints": [120119], "characters": "\uD835\uDD37" },
+  "&zhcy;": { "codepoints": [1078], "characters": "\u0436" },
+  "&zigrarr;": { "codepoints": [8669], "characters": "\u21DD" },
+  "&zopf;": { "codepoints": [120171], "characters": "\uD835\uDD6B" },
+  "&zscr;": { "codepoints": [120015], "characters": "\uD835\uDCCF" },
+  "&zwj;": { "codepoints": [8205], "characters": "\u200D" },
+  "&zwnj;": { "codepoints": [8204], "characters": "\u200C" }
+}