evaluator_dispatch.h

#ifndef SOURCEMETA_BLAZE_EVALUATOR_DISPATCH_H_
#define SOURCEMETA_BLAZE_EVALUATOR_DISPATCH_H_
 
// NOLINTNEXTLINE(misc-header-include-cycle)
#include <sourcemeta/blaze/evaluator.h>
 
#include <sourcemeta/core/crypto.h>
#include <sourcemeta/core/css.h>
#include <sourcemeta/core/dns.h>
#include <sourcemeta/core/email.h>
#include <sourcemeta/core/ip.h>
#include <sourcemeta/core/regex.h>
#include <sourcemeta/core/time.h>
#include <sourcemeta/core/uritemplate.h>
 
#include <cassert> // assert
 
// TODO(C++23): Replace SOURCEMETA_ASSUME with [[assume]] when available
// across all compilers (Clang 19, GCC 13)
#if defined(__clang__)
#define SOURCEMETA_ASSUME(x)                                                   \
  assert(x);                                                                   \
  __builtin_assume(x)
#else
#define SOURCEMETA_ASSUME(x) assert(x)
#endif
 
#define SOURCEMETA_STRINGIFY(x) #x
 
#define EVALUATE_PUSH()                                                        \
  if constexpr (Track) {                                                       \
    context.evaluator->evaluate_path.push_back(                                \
        context.schema->extra[instruction.extra_index]                         \
            .relative_schema_location);                                        \
  }                                                                            \
  if constexpr (HasCallback) {                                                 \
    context.evaluator->instance_location.push_back(                            \
        instruction.relative_instance_location);                               \
  }                                                                            \
  if constexpr (Dynamic) {                                                     \
    context.evaluator->resources.push_back(                                    \
        context.schema->extra[instruction.extra_index].schema_resource);       \
  }                                                                            \
  if constexpr (HasCallback) {                                                 \
    (*context.callback)(EvaluationType::Pre, true, instruction,                \
                        context.schema->extra[instruction.extra_index],        \
                        context.evaluator->evaluate_path,                      \
                        context.evaluator->instance_location,                  \
                        Evaluator::NULL_VALUE);                                \
  }
 
#define EVALUATE_POP()                                                         \
  if constexpr (HasCallback) {                                                 \
    (*context.callback)(EvaluationType::Post, result, instruction,             \
                        context.schema->extra[instruction.extra_index],        \
                        context.evaluator->evaluate_path,                      \
                        context.evaluator->instance_location,                  \
                        Evaluator::NULL_VALUE);                                \
  }                                                                            \
  if constexpr (Track) {                                                       \
    context.evaluator->evaluate_path.pop_back(                                 \
        context.schema->extra[instruction.extra_index]                         \
            .relative_schema_location.size());                                 \
  }                                                                            \
  if constexpr (HasCallback) {                                                 \
    context.evaluator->instance_location.pop_back(                             \
        instruction.relative_instance_location.size());                        \
  }                                                                            \
  if constexpr (Dynamic) {                                                     \
    context.evaluator->resources.pop_back();                                   \
  }
 
#define EVALUATE_BEGIN(instruction_type, precondition)                         \
  assert(instruction.type == InstructionIndex::instruction_type);              \
  const auto &target{resolve_target(                                           \
      context.property_target,                                                 \
      resolve_instance(instance, instruction.relative_instance_location))};    \
  if (!(precondition)) [[unlikely]] {                                          \
    return true;                                                               \
  }                                                                            \
  [[maybe_unused]] constexpr bool track{Track || HasCallback};                 \
  EVALUATE_PUSH()                                                              \
  bool result{false};
 
#define EVALUATE_BEGIN_NON_STRING(instruction_type, precondition)              \
  assert(instruction.type == InstructionIndex::instruction_type);              \
  const auto &target{                                                          \
      resolve_instance(instance, instruction.relative_instance_location)};     \
  if (!(precondition)) [[unlikely]] {                                          \
    return true;                                                               \
  }                                                                            \
  [[maybe_unused]] constexpr bool track{Track || HasCallback};                 \
  EVALUATE_PUSH()                                                              \
  bool result{false};
 
#define EVALUATE_BEGIN_IF_STRING(instruction_type)                             \
  assert(instruction.type == InstructionIndex::instruction_type);              \
  const auto *maybe_target{                                                    \
      resolve_string_target(context.property_target, instance,                 \
                            instruction.relative_instance_location)};          \
  if (!maybe_target) [[unlikely]] {                                            \
    return true;                                                               \
  }                                                                            \
  EVALUATE_PUSH()                                                              \
  const auto &target{*maybe_target};                                           \
  bool result{false};
 
#define EVALUATE_BEGIN_TRY_TARGET(instruction_type)                            \
  assert(instruction.type == InstructionIndex::instruction_type);              \
  const auto &target{instance};                                                \
  if (!target.is_object()) [[unlikely]] {                                      \
    return true;                                                               \
  }                                                                            \
  assert(!instruction.relative_instance_location.empty());                     \
  const auto *target_check{                                                    \
      instruction.relative_instance_location.size() == 1                       \
          ? target.try_at(                                                     \
                instruction.relative_instance_location.at(0).to_property(),    \
                instruction.relative_instance_location.at(0).property_hash())  \
          : try_get(target, instruction.relative_instance_location)};          \
  if (!target_check) [[unlikely]] {                                            \
    return true;                                                               \
  }                                                                            \
  EVALUATE_PUSH()                                                              \
  bool result{false};
 
#define EVALUATE_BEGIN_NO_PRECONDITION(instruction_type)                       \
  assert(instruction.type == InstructionIndex::instruction_type);              \
  [[maybe_unused]] constexpr bool track{Track || HasCallback};                 \
  EVALUATE_PUSH()                                                              \
  bool result{false};
 
#define EVALUATE_BEGIN_NO_PRECONDITION_AND_NO_PUSH(instruction_type)           \
  assert(instruction.type == InstructionIndex::instruction_type);              \
  if constexpr (HasCallback) {                                                 \
    (*context.callback)(EvaluationType::Pre, true, instruction,                \
                        context.schema->extra[instruction.extra_index],        \
                        context.evaluator->evaluate_path,                      \
                        context.evaluator->instance_location,                  \
                        Evaluator::NULL_VALUE);                                \
  }                                                                            \
  bool result{true};
 
#define EVALUATE_BEGIN_PASS_THROUGH(instruction_type)                          \
  assert(instruction.type == InstructionIndex::instruction_type);              \
  bool result{true};
 
#define EVALUATE_END(instruction_type)                                         \
  EVALUATE_POP()                                                               \
  return result;
 
#define EVALUATE_END_NO_POP(instruction_type)                                  \
  if constexpr (HasCallback) {                                                 \
    (*context.callback)(EvaluationType::Post, result, instruction,             \
                        context.schema->extra[instruction.extra_index],        \
                        context.evaluator->evaluate_path,                      \
                        context.evaluator->instance_location,                  \
                        Evaluator::NULL_VALUE);                                \
  }                                                                            \
  return result;
 
#define EVALUATE_END_PASS_THROUGH(instruction_type) return result;
 
#define EVALUATE_ANNOTATION(instruction_type, destination, annotation_value)   \
  if constexpr (HasCallback) {                                                 \
    context.evaluator->evaluate_path.push_back(                                \
        context.schema->extra[instruction.extra_index]                         \
            .relative_schema_location);                                        \
    context.evaluator->instance_location.push_back(                            \
        instruction.relative_instance_location);                               \
    const auto &reported_location{destination};                                \
    (*context.callback)(EvaluationType::Pre, true, instruction,                \
                        context.schema->extra[instruction.extra_index],        \
                        context.evaluator->evaluate_path, reported_location,   \
                        Evaluator::NULL_VALUE);                                \
    (*context.callback)(EvaluationType::Post, true, instruction,               \
                        context.schema->extra[instruction.extra_index],        \
                        context.evaluator->evaluate_path, reported_location,   \
                        annotation_value);                                     \
    context.evaluator->evaluate_path.pop_back(                                 \
        context.schema->extra[instruction.extra_index]                         \
            .relative_schema_location.size());                                 \
    context.evaluator->instance_location.pop_back(                             \
        instruction.relative_instance_location.size());                        \
  }                                                                            \
  return true;
 
#define EVALUATE_RECURSE(child, target)                                        \
  evaluate_instruction(child, target, depth + 1, context)
#define EVALUATE_RECURSE_ON_PROPERTY_NAME(child, target, name)                 \
  evaluate_instruction_with_property(child, target, depth + 1, context, name)
 
namespace sourcemeta::blaze::dispatch {
using namespace sourcemeta::core;
 
// The recursion depth past which evaluation is assumed to be non-terminating
constexpr auto DEPTH_LIMIT{300};
 
inline auto resolve_target(const JSON::String *property_target,
                           const JSON &instance) noexcept -> const JSON & {
  if (property_target != nullptr) [[unlikely]] {
    return Evaluator::EMPTY_STRING;
  }
 
  // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
  return instance;
}
 
inline auto resolve_instance(const JSON &instance,
                             const Pointer &relative_instance_location)
    -> const JSON & {
  if (relative_instance_location.empty()) {
    // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
    return instance;
  }
 
  // A single property is what almost every instruction that navigates at all
  // carries, and resolving it here keeps the lookup inline, rather than
  // calling out to the pointer walk that the general case needs
  if (relative_instance_location.size() == 1 &&
      relative_instance_location.at(0).is_property()) {
    return instance.at(relative_instance_location.at(0).to_property(),
                       relative_instance_location.at(0).property_hash());
  }
 
  return get(instance, relative_instance_location);
}
 
inline auto
resolve_string_target(const JSON::String *property_target, const JSON &instance,
                      const Pointer &relative_instance_location) noexcept
    -> const JSON::String * {
  if (property_target != nullptr) [[unlikely]] {
    return property_target;
  }
 
  const auto &target{resolve_instance(instance, relative_instance_location)};
  if (!target.is_string()) [[unlikely]] {
    return nullptr;
  } else {
    return &target.to_string();
  }
}
 
inline auto named_index(const ValueNamedIndexes &indexes,
                        const JSON::String &name,
                        const JSON::Object::hash_type &name_hash) noexcept
    -> const ValueUnsignedInteger * {
  // Few enough names come without a table of contents, as reaching one costs
  // more than scanning them, so the whole range is the candidate range
  std::size_t first{1};
  std::size_t last{indexes.first.size()};
  if (!indexes.second.empty()) {
    // A name whose size no entry has cannot match, which settles most of the
    // misses without comparing against any entry at all
    if (name.size() >= indexes.second.size()) {
      return nullptr;
    }
 
    const auto &bounds{indexes.second[name.size()]};
    if (bounds.second == 0) {
      return nullptr;
    }
 
    first = bounds.first;
    last = bounds.second;
  }
 
  // A perfect hash records the name's size, so matching one is proof the names
  // are equal and only a longer name needs comparing. Whether the hash is
  // perfect depends on the name alone, so it is decided once rather than per
  // entry, as `JSONObject` does for the same reason
  constexpr sourcemeta::core::PropertyHashJSON<JSON::String> HASHER{};
  if (HASHER.is_perfect(name_hash)) {
    for (auto position = first; position <= last; position++) {
      const auto &entry{indexes.first[position - 1]};
      if (std::get<0>(entry) == name_hash) {
        return &std::get<1>(entry);
      }
    }
  } else {
    for (auto position = first; position <= last; position++) {
      const auto &entry{indexes.first[position - 1]};
      if (std::get<0>(entry) == name_hash && std::get<2>(entry) == name) {
        return &std::get<1>(entry);
      }
    }
  }
 
  return nullptr;
}
 
// `std::bitset::test` bounds-checks its index and throws when it is out of
// range, which every type check would pay on every value it looks at. A
// `JSON::Type` is always a valid index into a set that holds one bit per type,
// so the check can never fire and the subscript is used instead
inline auto type_set_test(const ValueTypes &types,
                          const JSON::Type type) noexcept -> bool {
  assert(std::to_underlying(type) < types.size());
  return types[std::to_underlying(type)];
}
 
inline auto effective_type_strict_real(const JSON &instance) noexcept
    -> JSON::Type {
  const auto real_type{instance.type()};
  switch (real_type) {
    case JSON::Type::Decimal:
      return instance.to_decimal().is_integer() ? JSON::Type::Integer
                                                : JSON::Type::Real;
    default:
      return real_type;
  }
}
 
// An integral number that no 64-bit integer can hold cannot be narrowed to one
// to be compared, and `as_integer` throws rather than saturating, so the
// comparison happens in a domain wide enough to hold any of them instead.
// A real converts through `exact_from` because the constructor spells a double
// with 17 significant digits, which is too few to tell apart two integers that
// a bound of this width can sit between
// Normalising a decimal to the integer or real it represents cannot change
// whether a type set holds it when the set treats all three number kinds
// alike, which is what `"type": "number"` compiles to. Deciding this once per
// instruction keeps the normalisation out of the loop, rather than trading its
// call for a branch on every element
inline auto type_set_spans_numbers(const ValueTypes &types) noexcept -> bool {
  const auto integer{types[std::to_underlying(JSON::Type::Integer)]};
  return types[std::to_underlying(JSON::Type::Real)] == integer &&
         types[std::to_underlying(JSON::Type::Decimal)] == integer;
}
 
template <bool Normalise>
inline auto type_in_set(const JSON &instance, const ValueTypes &types) noexcept
    -> bool {
  if constexpr (Normalise) {
    return type_set_test(types, effective_type_strict_real(instance));
  } else {
    return type_set_test(types, instance.type());
  }
}
 
template <bool Normalise>
inline auto array_items_in_type_set(const JSON &target,
                                    const ValueTypes &types) noexcept -> bool {
  for (const auto &entry : target.as_array()) {
    if (!type_in_set<Normalise>(entry, types)) [[unlikely]] {
      return false;
    }
  }
 
  return true;
}
 
template <bool Normalise>
inline auto object_values_in_type_set(const JSON &target,
                                      const ValueTypes &types) noexcept
    -> bool {
  for (const auto &entry : target.as_object()) {
    if (!type_in_set<Normalise>(entry.second, types)) [[unlikely]] {
      return false;
    }
  }
 
  return true;
}
 
template <bool Normalise>
inline auto items_are_bounded_arrays_in_type_set(
    const JSON &target, const ValueTypes &types, const std::size_t minimum,
    const std::optional<std::size_t> &maximum) noexcept -> bool {
  for (const auto &item : target.as_array()) {
    if (item.type() != JSON::Type::Array || item.array_size() < minimum ||
        (maximum.has_value() && item.array_size() > maximum.value()))
        [[unlikely]] {
      return false;
    }
 
    if (!array_items_in_type_set<Normalise>(item, types)) [[unlikely]] {
      return false;
    }
  }
 
  return true;
}
 
inline auto as_decimal(const JSON &instance) -> Decimal {
  assert(instance.is_integral());
  return instance.is_decimal() ? instance.to_decimal()
                               : Decimal::exact_from(instance.to_real());
}
 
inline auto integer_within_bounds(const JSON &target,
                                  const ValueIntegerBounds &value) -> bool {
  if (target.is_integer()) {
    const auto integer{target.to_integer()};
    return integer >= value.first && integer <= value.second;
  }
 
  if (target.is_integral()) {
    const auto decimal{as_decimal(target)};
    return decimal >= Decimal{value.first} && decimal <= Decimal{value.second};
  }
 
  return false;
}
 
template <typename T>
inline auto assume_value(const Value &variant) noexcept -> const T & {
  const auto *pointer{std::get_if<T>(&variant)};
  SOURCEMETA_ASSUME(pointer != nullptr);
  return *pointer;
}
 
template <typename T>
inline auto assume_value_copy(const Value &variant) noexcept -> T {
  const auto *pointer{std::get_if<T>(&variant)};
  SOURCEMETA_ASSUME(pointer != nullptr);
  return *pointer;
}
 
template <bool Track, bool Dynamic, bool HasCallback> struct DispatchContext {
  const sourcemeta::blaze::Template *schema;
  const sourcemeta::blaze::Callback *callback;
  sourcemeta::blaze::Evaluator *evaluator;
  const sourcemeta::core::JSON::String *property_target;
};
 
template <bool Track, bool Dynamic, bool HasCallback>
inline auto
evaluate_instruction(const sourcemeta::blaze::Instruction &instruction,
                     const sourcemeta::core::JSON &instance,
                     const std::uint64_t depth,
                     DispatchContext<Track, Dynamic, HasCallback> &context)
    -> bool;
 
template <bool Track, bool Dynamic, bool HasCallback>
inline auto evaluate_instruction_with_property(
    const sourcemeta::blaze::Instruction &instruction,
    const sourcemeta::core::JSON &instance, const std::uint64_t depth,
    DispatchContext<Track, Dynamic, HasCallback> &context,
    const sourcemeta::core::JSON::String &name) -> bool;
 
#define INSTRUCTION_HANDLER(name)                                              \
  template <bool Track, bool Dynamic, bool HasCallback>                        \
  static inline auto name(                                                     \
      [[maybe_unused]] const sourcemeta::blaze::Instruction &instruction,      \
      [[maybe_unused]] const sourcemeta::core::JSON &instance,                 \
      [[maybe_unused]] const std::uint64_t depth,                              \
      [[maybe_unused]] DispatchContext<Track, Dynamic, HasCallback> &context)  \
      -> bool
 
#define INSTRUCTION_DIRECT(name, value_type)                                   \
  SOURCEMETA_FORCEINLINE inline auto DIRECT_##name(                            \
      const sourcemeta::core::JSON &target, const value_type &value)           \
      ->bool
 
#define INSTRUCTION_DIRECT_COPY(name, value_type)                              \
  SOURCEMETA_FORCEINLINE inline auto DIRECT_##name(                            \
      const sourcemeta::core::JSON &target, const value_type value)            \
      ->bool
 
#define DIRECT(name, target, value) DIRECT_##name(target, value)
 
// Forward declarations
INSTRUCTION_DIRECT_COPY(LoopItemsIntegerBounded, ValueIntegerBounds);
 
// These handlers take their names from the instructions they implement, which
// `InstructionIndex` spells the same way and trace output emits verbatim
// NOLINTBEGIN(readability-identifier-naming)
INSTRUCTION_HANDLER(AssertionFail) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionFail);
  EVALUATE_END(AssertionFail);
}
 
INSTRUCTION_HANDLER(AssertionDefines) {
  EVALUATE_BEGIN_NON_STRING(AssertionDefines, target.is_object());
  const auto &value{assume_value<ValueProperty>(instruction.value)};
  result = target.defines(value.first, value.second);
  EVALUATE_END(AssertionDefines);
}
 
INSTRUCTION_HANDLER(AssertionDefinesStrict) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionDefinesStrict);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueProperty>(instruction.value)};
  result = target.is_object() && target.defines(value.first, value.second);
  EVALUATE_END(AssertionDefinesStrict);
}
 
INSTRUCTION_HANDLER(AssertionDefinesAll) {
  EVALUATE_BEGIN_NON_STRING(AssertionDefinesAll, target.is_object());
  const auto &value{assume_value<ValueStringSet>(instruction.value)};
  // Otherwise we are we even emitting this instruction?
  assert(value.size() > 1);
 
  // Otherwise there is no way the instance can satisfy it anyway
  if (value.size() <= target.object_size()) [[likely]] {
    result = true;
    const auto &object{target.as_object()};
    for (const auto &property : value) {
      if (!object.defines(property.first, property.second)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END(AssertionDefinesAll);
}
 
INSTRUCTION_HANDLER(AssertionDefinesAllStrict) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionDefinesAllStrict);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueStringSet>(instruction.value)};
  // Otherwise we are we even emitting this instruction?
  assert(value.size() > 1);
 
  // Otherwise there is no way the instance can satisfy it anyway
  if (target.is_object() && value.size() <= target.object_size()) [[likely]] {
    result = true;
    const auto &object{target.as_object()};
    for (const auto &property : value) {
      if (!object.defines(property.first, property.second)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END(AssertionDefinesAllStrict);
}
 
INSTRUCTION_HANDLER(AssertionDefinesExactly) {
  EVALUATE_BEGIN_NON_STRING(AssertionDefinesExactly, target.is_object());
  const auto &value{assume_value<ValueStringSet>(instruction.value)};
  // Otherwise we are we even emitting this instruction?
  assert(value.size() > 1);
  const auto &object{target.as_object()};
 
  if (value.size() == object.size()) [[likely]] {
    result = true;
    for (const auto &property : value) {
      if (!object.defines(property.first, property.second)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END(AssertionDefinesExactly);
}
 
INSTRUCTION_HANDLER(AssertionDefinesExactlyStrict) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionDefinesExactlyStrict);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  if (target.is_object()) [[likely]] {
    const auto &value{assume_value<ValueStringSet>(instruction.value)};
    // Otherwise we are we even emitting this instruction?
    assert(value.size() > 1);
    const auto &object{target.as_object()};
 
    if (value.size() == object.size()) [[likely]] {
      result = true;
      for (const auto &property : value) {
        if (!object.defines(property.first, property.second)) [[unlikely]] {
          result = false;
          break;
        }
      }
    }
  }
 
  EVALUATE_END(AssertionDefinesExactlyStrict);
}
 
INSTRUCTION_HANDLER(AssertionDefinesExactlyStrictHash3) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionDefinesExactlyStrictHash3);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  if (target.is_object()) [[likely]] {
    // TODO: Take advantage of the table of contents structure to speed up
    // checks
    const auto &value{assume_value<ValueStringHashes>(instruction.value)};
    assert(value.first.size() == 3);
    const auto &object{target.as_object()};
 
    // A perfect hash records the key's size, which the compiler requires of
    // every key here, so matching one proves the keys equal and the unrolled
    // permutation check compares nothing but hashes
    result =
        object.size() == 3 && ((value.first.at(0).first == object.at(0).hash &&
                                value.first.at(1).first == object.at(1).hash &&
                                value.first.at(2).first == object.at(2).hash) ||
                               (value.first.at(0).first == object.at(0).hash &&
                                value.first.at(1).first == object.at(2).hash &&
                                value.first.at(2).first == object.at(1).hash) ||
                               (value.first.at(0).first == object.at(1).hash &&
                                value.first.at(1).first == object.at(0).hash &&
                                value.first.at(2).first == object.at(2).hash) ||
                               (value.first.at(0).first == object.at(1).hash &&
                                value.first.at(1).first == object.at(2).hash &&
                                value.first.at(2).first == object.at(0).hash) ||
                               (value.first.at(0).first == object.at(2).hash &&
                                value.first.at(1).first == object.at(0).hash &&
                                value.first.at(2).first == object.at(1).hash) ||
                               (value.first.at(0).first == object.at(2).hash &&
                                value.first.at(1).first == object.at(1).hash &&
                                value.first.at(2).first == object.at(0).hash));
  }
 
  EVALUATE_END(AssertionDefinesExactlyStrictHash3);
}
 
INSTRUCTION_HANDLER(AssertionPropertyDependencies) {
  EVALUATE_BEGIN_NON_STRING(AssertionPropertyDependencies, target.is_object());
  const auto &value{assume_value<ValueStringMap>(instruction.value)};
  // Otherwise we are we even emitting this instruction?
  assert(!value.empty());
  result = true;
  const auto &object{target.as_object()};
  const sourcemeta::core::PropertyHashJSON<ValueString> hasher;
  for (const auto &entry : value) {
    if (!object.defines(entry.first, entry.hash)) {
      continue;
    }
 
    assert(!entry.second.empty());
    for (const auto &dependency : entry.second) {
      if (!object.defines(dependency, hasher(dependency))) [[unlikely]] {
        result = false;
        EVALUATE_END(AssertionPropertyDependencies);
      }
    }
  }
 
  EVALUATE_END(AssertionPropertyDependencies);
}
 
INSTRUCTION_DIRECT_COPY(AssertionType, ValueType) {
  // In non-strict mode, we consider a real number that represents an
  // integer to be an integer
  return target.type() == value ||
         (value == JSON::Type::Integer && target.is_integral());
}
 
INSTRUCTION_HANDLER(AssertionType) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionType);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  // TODO: Maybe make this instruction about integers, as it is the
  // only where where it is actually useful?
  assert(value == JSON::Type::Integer);
  SOURCEMETA_ASSUME(value == JSON::Type::Integer);
  result = DIRECT(AssertionType, target, value);
  EVALUATE_END(AssertionType);
}
 
INSTRUCTION_DIRECT(AssertionTypeAny, ValueTypes) {
  // In non-strict mode, we consider a real number that represents an
  // integer to be an integer
  return type_set_test(value, target.type()) ||
         (type_set_test(value, JSON::Type::Integer) && target.is_integral());
}
 
INSTRUCTION_HANDLER(AssertionTypeAny) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeAny);
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  result = DIRECT(AssertionTypeAny, target, value);
  EVALUATE_END(AssertionTypeAny);
}
 
INSTRUCTION_DIRECT_COPY(AssertionTypeStrict, ValueType) {
  return effective_type_strict_real(target) == value;
}
 
INSTRUCTION_HANDLER(AssertionTypeStrict) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeStrict);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  result = DIRECT(AssertionTypeStrict, target, value);
  EVALUATE_END(AssertionTypeStrict);
}
 
INSTRUCTION_DIRECT(AssertionTypeStrictAny, ValueTypes) {
  return type_set_test(value, effective_type_strict_real(target));
}
 
INSTRUCTION_HANDLER(AssertionTypeStrictAny) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeStrictAny);
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  result = DIRECT(AssertionTypeStrictAny, target, value);
  EVALUATE_END(AssertionTypeStrictAny);
}
 
INSTRUCTION_DIRECT(AssertionNotTypeStrictAny, ValueTypes) {
  return !type_set_test(value, effective_type_strict_real(target));
}
 
INSTRUCTION_HANDLER(AssertionNotTypeStrictAny) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionNotTypeStrictAny);
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  result = DIRECT(AssertionNotTypeStrictAny, target, value);
  EVALUATE_END(AssertionNotTypeStrictAny);
}
 
INSTRUCTION_DIRECT(AssertionTypeStringBounded, ValueRange) {
  const auto &[minimum, maximum, exhaustive] = value;
  return target.type() == JSON::Type::String &&
         target.string_size() >= minimum &&
         (!maximum.has_value() || target.string_size() <= maximum.value());
}
 
INSTRUCTION_HANDLER(AssertionTypeStringBounded) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeStringBounded);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueRange>(instruction.value)};
  assert(!std::get<1>(value).has_value() ||
         std::get<1>(value).value() >= std::get<0>(value));
  assert(!std::get<2>(value));
  result = DIRECT(AssertionTypeStringBounded, target, value);
  EVALUATE_END(AssertionTypeStringBounded);
}
 
INSTRUCTION_HANDLER(AssertionTypeStringUpper) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeStringUpper);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = target.is_string() && target.string_size() <= value;
  EVALUATE_END(AssertionTypeStringUpper);
}
 
INSTRUCTION_DIRECT(AssertionTypeArrayBounded, ValueRange) {
  const auto &[minimum, maximum, exhaustive] = value;
  // Require early breaking
  assert(!exhaustive);
  SOURCEMETA_ASSUME(!exhaustive);
  return target.type() == JSON::Type::Array && target.array_size() >= minimum &&
         (!maximum.has_value() || target.array_size() <= maximum.value());
}
 
INSTRUCTION_HANDLER(AssertionTypeArrayBounded) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeArrayBounded);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueRange>(instruction.value)};
  assert(!std::get<1>(value).has_value() ||
         std::get<1>(value).value() >= std::get<0>(value));
  result = DIRECT(AssertionTypeArrayBounded, target, value);
  EVALUATE_END(AssertionTypeArrayBounded);
}
 
INSTRUCTION_HANDLER(AssertionTypeArrayUpper) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeArrayUpper);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = target.is_array() && target.array_size() <= value;
  EVALUATE_END(AssertionTypeArrayUpper);
}
 
INSTRUCTION_HANDLER(AssertionTypeObjectBounded) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeObjectBounded);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueRange>(instruction.value)};
  const auto &[minimum, maximum, exhaustive] = value;
  assert(!maximum.has_value() || maximum.value() >= minimum);
  // Require early breaking
  assert(!exhaustive);
  SOURCEMETA_ASSUME(!exhaustive);
  result = target.type() == JSON::Type::Object &&
           target.object_size() >= minimum &&
           (!maximum.has_value() || target.object_size() <= maximum.value());
  EVALUATE_END(AssertionTypeObjectBounded);
}
 
INSTRUCTION_HANDLER(AssertionTypeObjectUpper) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionTypeObjectUpper);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = target.is_object() && target.object_size() <= value;
  EVALUATE_END(AssertionTypeObjectUpper);
}
 
INSTRUCTION_HANDLER(AssertionRegex) {
  EVALUATE_BEGIN_IF_STRING(AssertionRegex);
  const auto &value{assume_value<ValueRegex>(instruction.value)};
  result = matches(value.first, target);
  EVALUATE_END(AssertionRegex);
}
 
INSTRUCTION_HANDLER(AssertionStringSizeLess) {
  EVALUATE_BEGIN_IF_STRING(AssertionStringSizeLess);
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = (JSON::size(target) < value);
  EVALUATE_END(AssertionStringSizeLess);
}
 
INSTRUCTION_HANDLER(AssertionStringSizeGreater) {
  EVALUATE_BEGIN_IF_STRING(AssertionStringSizeGreater);
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = (JSON::size(target) > value);
  EVALUATE_END(AssertionStringSizeGreater);
}
 
INSTRUCTION_HANDLER(AssertionArraySizeLess) {
  EVALUATE_BEGIN_NON_STRING(AssertionArraySizeLess, target.is_array());
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = (target.array_size() < value);
  EVALUATE_END(AssertionArraySizeLess);
}
 
INSTRUCTION_HANDLER(AssertionArraySizeGreater) {
  EVALUATE_BEGIN_NON_STRING(AssertionArraySizeGreater, target.is_array());
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = (target.array_size() > value);
  EVALUATE_END(AssertionArraySizeGreater);
}
 
INSTRUCTION_HANDLER(AssertionObjectSizeLess) {
  EVALUATE_BEGIN_NON_STRING(AssertionObjectSizeLess, target.is_object());
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = (target.object_size() < value);
  EVALUATE_END(AssertionObjectSizeLess);
}
 
INSTRUCTION_HANDLER(AssertionObjectSizeGreater) {
  EVALUATE_BEGIN_NON_STRING(AssertionObjectSizeGreater, target.is_object());
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  result = (target.object_size() > value);
  EVALUATE_END(AssertionObjectSizeGreater);
}
 
INSTRUCTION_DIRECT(AssertionEqual, ValueJSON) { return target == value; }
 
INSTRUCTION_HANDLER(AssertionEqual) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionEqual);
  const auto &value{assume_value<ValueJSON>(instruction.value)};
 
  if (context.property_target) [[unlikely]] {
    result = value.is_string() && value.to_string() == *context.property_target;
  } else {
    const auto &target{
        resolve_instance(instance, instruction.relative_instance_location)};
    result = DIRECT(AssertionEqual, target, value);
  }
 
  EVALUATE_END(AssertionEqual);
}
 
INSTRUCTION_DIRECT(AssertionEqualsAny, ValueSet) {
  return value.contains(target);
}
 
INSTRUCTION_HANDLER(AssertionEqualsAny) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionEqualsAny);
  const auto &value{assume_value<ValueSet>(instruction.value)};
 
  if (context.property_target) [[unlikely]] {
    // TODO: This involves a string copy
    result = value.contains(JSON{*context.property_target});
  } else {
    const auto &target{
        resolve_instance(instance, instruction.relative_instance_location)};
    result = DIRECT(AssertionEqualsAny, target, value);
  }
 
  EVALUATE_END(AssertionEqualsAny);
}
 
INSTRUCTION_DIRECT(AssertionEqualsAnyStringHash, ValueStringHashes) {
  if (!target.is_string()) [[unlikely]] {
    return false;
  }
  const auto &target_string{target.to_string()};
  const auto string_size{target_string.size()};
  const sourcemeta::core::PropertyHashJSON<ValueString> hasher;
  const auto value_hash{hasher(target_string)};
  if (string_size < value.second.size()) [[likely]] {
    const auto &hint{value.second[string_size]};
    if (hint.second != 0) [[likely]] {
      for (std::size_t index = hint.first - 1; index < hint.second; index++) {
        if (value.first[index].first == value_hash) {
          return true;
        }
      }
    }
  }
  return false;
}
 
INSTRUCTION_HANDLER(AssertionEqualsAnyStringHash) {
  EVALUATE_BEGIN_NO_PRECONDITION(AssertionEqualsAnyStringHash);
  const auto &value{assume_value<ValueStringHashes>(instruction.value)};
 
  if (context.property_target) [[unlikely]] {
    const sourcemeta::core::PropertyHashJSON<ValueString> hasher;
    const auto value_hash{hasher(*context.property_target)};
    const auto string_size{context.property_target->size()};
    if (string_size < value.second.size()) [[likely]] {
      const auto &hint{value.second[string_size]};
      assert(hint.first <= hint.second);
      SOURCEMETA_ASSUME(hint.first <= hint.second);
      if (hint.second != 0) [[likely]] {
        for (std::size_t index = hint.first - 1; index < hint.second; index++) {
          assert(hasher.is_perfect(value.first[index].first));
          if (value.first[index].first == value_hash) {
            result = true;
            break;
          }
        }
      }
    }
  } else {
    const auto &target{
        resolve_instance(instance, instruction.relative_instance_location)};
    result = DIRECT(AssertionEqualsAnyStringHash, target, value);
  }
 
  EVALUATE_END(AssertionEqualsAnyStringHash);
}
 
INSTRUCTION_HANDLER(AssertionGreaterEqual) {
  EVALUATE_BEGIN_NON_STRING(AssertionGreaterEqual, target.is_number());
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  result = target >= value;
  EVALUATE_END(AssertionGreaterEqual);
}
 
INSTRUCTION_HANDLER(AssertionLessEqual) {
  EVALUATE_BEGIN_NON_STRING(AssertionLessEqual, target.is_number());
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  result = target <= value;
  EVALUATE_END(AssertionLessEqual);
}
 
INSTRUCTION_HANDLER(AssertionGreater) {
  EVALUATE_BEGIN_NON_STRING(AssertionGreater, target.is_number());
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  result = target > value;
  EVALUATE_END(AssertionGreater);
}
 
INSTRUCTION_HANDLER(AssertionLess) {
  EVALUATE_BEGIN_NON_STRING(AssertionLess, target.is_number());
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  result = target < value;
  EVALUATE_END(AssertionLess);
}
 
INSTRUCTION_HANDLER(AssertionUnique) {
  EVALUATE_BEGIN_NON_STRING(AssertionUnique, target.is_array());
  result = target.unique();
  EVALUATE_END(AssertionUnique);
}
 
INSTRUCTION_HANDLER(AssertionDivisible) {
  EVALUATE_BEGIN_NON_STRING(AssertionDivisible, target.is_number());
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  assert(value.is_number());
  result = target.divisible_by(value);
  EVALUATE_END(AssertionDivisible);
}
 
INSTRUCTION_DIRECT(AssertionTypeIntegerBounded, ValueIntegerBounds) {
  return integer_within_bounds(target, value);
}
 
INSTRUCTION_HANDLER(AssertionTypeIntegerBounded) {
  EVALUATE_BEGIN_NON_STRING(AssertionTypeIntegerBounded, true);
  result = DIRECT(AssertionTypeIntegerBounded, target,
                  assume_value_copy<ValueIntegerBounds>(instruction.value));
  EVALUATE_END(AssertionTypeIntegerBounded);
}
 
INSTRUCTION_DIRECT(AssertionTypeIntegerBoundedStrict, ValueIntegerBounds) {
  if (target.is_integer()) {
    const auto integer{target.to_integer()};
    return integer >= value.first && integer <= value.second;
  }
  return false;
}
 
INSTRUCTION_HANDLER(AssertionTypeIntegerBoundedStrict) {
  EVALUATE_BEGIN_NON_STRING(AssertionTypeIntegerBoundedStrict, true);
  result = DIRECT(AssertionTypeIntegerBoundedStrict, target,
                  assume_value_copy<ValueIntegerBounds>(instruction.value));
  EVALUATE_END(AssertionTypeIntegerBoundedStrict);
}
 
INSTRUCTION_DIRECT(AssertionTypeIntegerLowerBound, ValueIntegerBounds) {
  if (target.is_integer()) {
    return target.to_integer() >= value.first;
  }
  if (target.is_integral()) {
    return as_decimal(target) >= Decimal{value.first};
  }
  return false;
}
 
INSTRUCTION_HANDLER(AssertionTypeIntegerLowerBound) {
  EVALUATE_BEGIN_NON_STRING(AssertionTypeIntegerLowerBound, true);
  result = DIRECT(AssertionTypeIntegerLowerBound, target,
                  assume_value_copy<ValueIntegerBounds>(instruction.value));
  EVALUATE_END(AssertionTypeIntegerLowerBound);
}
 
INSTRUCTION_DIRECT(AssertionTypeIntegerLowerBoundStrict, ValueIntegerBounds) {
  if (target.is_integer()) {
    return target.to_integer() >= value.first;
  }
  // An integer too large for 64 bits is held as a decimal, which the strict
  // type check still reads as an integer when it was written as digits alone.
  // The bounded counterpart needs no such branch, as a value out of that range
  // cannot sit within bounds of that width either way
  if (effective_type_strict_real(target) == JSON::Type::Integer) {
    return target.to_decimal() >= Decimal{value.first};
  }
  return false;
}
 
INSTRUCTION_HANDLER(AssertionTypeIntegerLowerBoundStrict) {
  EVALUATE_BEGIN_NON_STRING(AssertionTypeIntegerLowerBoundStrict, true);
  result = DIRECT(AssertionTypeIntegerLowerBoundStrict, target,
                  assume_value_copy<ValueIntegerBounds>(instruction.value));
  EVALUATE_END(AssertionTypeIntegerLowerBoundStrict);
}
 
INSTRUCTION_DIRECT(AssertionNumberIntegerBounded, ValueIntegerBounds) {
  return integer_within_bounds(target, value);
}
 
INSTRUCTION_HANDLER(AssertionNumberIntegerBounded) {
  EVALUATE_BEGIN_NON_STRING(AssertionNumberIntegerBounded, target.is_number());
  result = DIRECT(AssertionNumberIntegerBounded, target,
                  assume_value_copy<ValueIntegerBounds>(instruction.value));
  EVALUATE_END(AssertionNumberIntegerBounded);
}
 
INSTRUCTION_HANDLER(AssertionNumberType) {
  EVALUATE_BEGIN_NON_STRING(AssertionNumberType, target.is_number());
  switch (assume_value_copy<ValueNumberType>(instruction.value)) {
    case ValueNumberType::Float:
      result = target.is_float();
      break;
    case ValueNumberType::Double:
      result = target.is_double();
      break;
  }
  EVALUATE_END(AssertionNumberType);
}
 
INSTRUCTION_HANDLER(AssertionStringType) {
  EVALUATE_BEGIN_IF_STRING(AssertionStringType);
  const auto value{assume_value_copy<ValueStringType>(instruction.value)};
  switch (value) {
    case ValueStringType::URI:
      result = URI::is_uri(target);
      break;
    case ValueStringType::URIReference:
      result = URI::is_uri_reference(target);
      break;
    case ValueStringType::URITemplate:
      result = URITemplate::is_uritemplate(target);
      break;
    case ValueStringType::IRI:
      result = URI::is_iri(target);
      break;
    case ValueStringType::IRIReference:
      result = URI::is_iri_reference(target);
      break;
    case ValueStringType::Email:
      result = is_email(target);
      break;
    case ValueStringType::IDNEmail:
      result = is_idn_email_uts46(target);
      break;
    case ValueStringType::IPv4:
      result = is_ipv4(target);
      break;
    case ValueStringType::IPv6:
      result = is_ipv6(target);
      break;
    case ValueStringType::Hostname:
      result = is_hostname(target);
      break;
    case ValueStringType::IDNHostname:
      result = is_idn_hostname(target);
      break;
    case ValueStringType::DateTime:
      result = is_rfc3339_datetime(target);
      break;
    case ValueStringType::Date:
      result = is_rfc3339_fulldate(target);
      break;
    case ValueStringType::Time:
      result = is_rfc3339_fulltime(target);
      break;
    case ValueStringType::PartialTime:
      result = is_rfc3339_partialtime_no_secfrac(target);
      break;
    case ValueStringType::Duration:
      result = is_rfc3339_duration(target);
      break;
    case ValueStringType::JSONPointer:
      result = is_pointer(target);
      break;
    case ValueStringType::RelativeJSONPointer:
      result = is_relative_pointer(target);
      break;
    case ValueStringType::UUID:
      result = is_uuid_like(target);
      break;
    case ValueStringType::Regex:
      result = is_regex_ecma(target);
      break;
    case ValueStringType::Color:
      result = is_css2_color(target);
      break;
    case ValueStringType::Base64:
      result = sourcemeta::core::is_base64(target);
      break;
    default:
      std::unreachable();
  }
 
  EVALUATE_END(AssertionStringType);
}
 
INSTRUCTION_HANDLER(AssertionPropertyType) {
  EVALUATE_BEGIN_TRY_TARGET(AssertionPropertyType);
  // Now here we refer to the actual property
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  // In non-strict mode, we consider a real number that represents an
  // integer to be an integer
  result = target_check->type() == value ||
           (value == JSON::Type::Integer && target_check->is_integral());
  EVALUATE_END(AssertionPropertyType);
}
 
INSTRUCTION_HANDLER(AssertionPropertyTypeEvaluate) {
  EVALUATE_BEGIN_TRY_TARGET(AssertionPropertyTypeEvaluate);
  // Now here we refer to the actual property
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  // In non-strict mode, we consider a real number that represents an
  // integer to be an integer
  result = target_check->type() == value ||
           (value == JSON::Type::Integer && target_check->is_integral());
 
  if (result) {
    context.evaluator->evaluate(target_check);
  }
 
  EVALUATE_END(AssertionPropertyTypeEvaluate);
}
 
INSTRUCTION_HANDLER(AssertionPropertyTypeStrict) {
  EVALUATE_BEGIN_TRY_TARGET(AssertionPropertyTypeStrict);
  // Now here we refer to the actual property
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  result = effective_type_strict_real(*target_check) == value;
  EVALUATE_END(AssertionPropertyTypeStrict);
}
 
INSTRUCTION_HANDLER(AssertionPropertyTypeStrictEvaluate) {
  EVALUATE_BEGIN_TRY_TARGET(AssertionPropertyTypeStrictEvaluate);
  // Now here we refer to the actual property
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  result = effective_type_strict_real(*target_check) == value;
 
  if (result) {
    context.evaluator->evaluate(target_check);
  }
 
  EVALUATE_END(AssertionPropertyTypeStrictEvaluate);
}
 
INSTRUCTION_HANDLER(AssertionPropertyEqual) {
  EVALUATE_BEGIN_TRY_TARGET(AssertionPropertyEqual);
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  // Now here we refer to the actual property
  result = DIRECT(AssertionEqual, *target_check, value);
  EVALUATE_END(AssertionPropertyEqual);
}
 
INSTRUCTION_HANDLER(AssertionPropertyTypeStrictAny) {
  EVALUATE_BEGIN_TRY_TARGET(AssertionPropertyTypeStrictAny);
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
  // Now here we refer to the actual property
  result = type_set_test(value, effective_type_strict_real(*target_check));
  EVALUATE_END(AssertionPropertyTypeStrictAny);
}
 
INSTRUCTION_HANDLER(AssertionPropertyTypeStrictAnyEvaluate) {
  EVALUATE_BEGIN_TRY_TARGET(AssertionPropertyTypeStrictAnyEvaluate);
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
  // Now here we refer to the actual property
  result = type_set_test(value, effective_type_strict_real(*target_check));
 
  if (result) {
    context.evaluator->evaluate(target_check);
  }
 
  EVALUATE_END(AssertionPropertyTypeStrictAnyEvaluate);
}
 
INSTRUCTION_HANDLER(AssertionObjectPropertiesSimple) {
  EVALUATE_BEGIN_NON_STRING(AssertionObjectPropertiesSimple, true);
  if (!target.is_object()) {
    EVALUATE_END(AssertionObjectPropertiesSimple);
  }
 
  const auto &value{assume_value<ValueObjectProperties>(instruction.value)};
  assert(value.size() >= instruction.children.size());
  assert(value.size() <= 32);
  static constexpr sourcemeta::core::PropertyHashJSON<ValueString>
      PROPERTY_HASHER;
  const auto &object{target.as_object()};
  const auto schema_size{value.size()};
  std::uint32_t seen{0};
  result = true;
 
  for (const auto &instance_entry : object) {
    const auto &instance_hash{instance_entry.hash};
    for (std::size_t schema_index = 0; schema_index < schema_size;
         schema_index++) {
      const auto &schema_hash{std::get<1>(value[schema_index])};
      // A perfect hash records the key's size, so matching one proves the keys
      // equal and only a longer key needs comparing
      if (schema_hash == instance_hash &&
          (PROPERTY_HASHER.is_perfect(instance_hash) ||
           instance_entry.first == std::get<0>(value[schema_index]))) {
        seen |= (static_cast<std::uint32_t>(1) << schema_index);
        if (schema_index < instruction.children.size()) {
          const auto &child{instruction.children[schema_index]};
          const auto &property_value{instance_entry.second};
          bool child_ok{false};
 
// NOLINTBEGIN(bugprone-macro-parentheses)
#define CHILD_DIRECT(name, accessor, value_type)                               \
  case name:                                                                   \
    child_ok =                                                                 \
        DIRECT(name, property_value, accessor<value_type>(child.value));       \
    break
 
          switch (child.type) {
            using enum InstructionIndex;
            CHILD_DIRECT(AssertionTypeStrict, assume_value_copy, ValueType);
            CHILD_DIRECT(AssertionType, assume_value_copy, ValueType);
            CHILD_DIRECT(AssertionTypeStrictAny, assume_value, ValueTypes);
            CHILD_DIRECT(AssertionTypeAny, assume_value, ValueTypes);
            CHILD_DIRECT(AssertionTypeStringBounded, assume_value, ValueRange);
            CHILD_DIRECT(AssertionEqual, assume_value, ValueJSON);
            CHILD_DIRECT(AssertionEqualsAny, assume_value, ValueSet);
            CHILD_DIRECT(AssertionEqualsAnyStringHash, assume_value,
                         ValueStringHashes);
            CHILD_DIRECT(AssertionTypeIntegerBounded, assume_value_copy,
                         ValueIntegerBounds);
            CHILD_DIRECT(AssertionTypeIntegerBoundedStrict, assume_value_copy,
                         ValueIntegerBounds);
            CHILD_DIRECT(AssertionTypeIntegerLowerBound, assume_value_copy,
                         ValueIntegerBounds);
            CHILD_DIRECT(AssertionTypeIntegerLowerBoundStrict,
                         assume_value_copy, ValueIntegerBounds);
            CHILD_DIRECT(LoopItemsIntegerBounded, assume_value_copy,
                         ValueIntegerBounds);
            default:
              child_ok = evaluate_instruction_without_callback(
                  child, property_value, depth + 1, context);
              break;
          }
 
// NOLINTEND(bugprone-macro-parentheses)
#undef CHILD_DIRECT
 
          if (!child_ok) [[unlikely]] {
            result = false;
            EVALUATE_END(AssertionObjectPropertiesSimple);
          }
        }
 
        break;
      }
    }
  }
 
  // Check required properties that were not seen
  const auto all_seen{schema_size == 32
                          ? ~std::uint32_t{0}
                          : (std::uint32_t{1} << schema_size) - 1};
  if (seen != all_seen) [[unlikely]] {
    for (std::size_t schema_index = 0; schema_index < schema_size;
         schema_index++) {
      if (std::get<2>(value[schema_index]) &&
          !(seen & (static_cast<std::uint32_t>(1) << schema_index))) {
        result = false;
        EVALUATE_END(AssertionObjectPropertiesSimple);
      }
    }
  }
 
  EVALUATE_END(AssertionObjectPropertiesSimple);
}
 
INSTRUCTION_HANDLER(AssertionArrayPrefix) {
  EVALUATE_BEGIN_NON_STRING(AssertionArrayPrefix, target.is_array());
  // Otherwise there is no point in emitting this instruction
  assert(!instruction.children.empty());
  result = target.empty();
  const auto prefixes{instruction.children.size() - 1};
  const auto array_size{target.array_size()};
  if (!result) [[likely]] {
    const auto pointer{
        array_size == prefixes ? prefixes : std::min(array_size, prefixes) - 1};
    const auto &entry{instruction.children[pointer]};
    result = true;
    assert(entry.type == sourcemeta::blaze::InstructionIndex::ControlGroup);
    SOURCEMETA_ASSUME(entry.type ==
                      sourcemeta::blaze::InstructionIndex::ControlGroup);
    for (const auto &child : entry.children) {
      if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END(AssertionArrayPrefix);
}
 
INSTRUCTION_HANDLER(AssertionArrayPrefixEvaluate) {
  EVALUATE_BEGIN_NON_STRING(AssertionArrayPrefixEvaluate, target.is_array());
  // Otherwise there is no point in emitting this instruction
  assert(!instruction.children.empty());
  result = target.empty();
  const auto prefixes{instruction.children.size() - 1};
  const auto array_size{target.array_size()};
  if (!result) [[likely]] {
    const auto pointer{
        array_size == prefixes ? prefixes : std::min(array_size, prefixes) - 1};
    const auto &entry{instruction.children[pointer]};
    result = true;
    assert(entry.type == sourcemeta::blaze::InstructionIndex::ControlGroup);
    SOURCEMETA_ASSUME(entry.type ==
                      sourcemeta::blaze::InstructionIndex::ControlGroup);
    for (const auto &child : entry.children) {
      if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
        result = false;
        EVALUATE_END(AssertionArrayPrefixEvaluate);
      }
    }
 
    assert(result);
    SOURCEMETA_ASSUME(result);
    if (array_size == prefixes) {
      context.evaluator->evaluate(&target);
    } else {
      for (std::size_t cursor = 0; cursor <= pointer; cursor++) {
        context.evaluator->evaluate(&target.at(cursor));
      }
    }
  }
 
  EVALUATE_END(AssertionArrayPrefixEvaluate);
}
 
INSTRUCTION_HANDLER(LogicalOr) {
  EVALUATE_BEGIN_NO_PRECONDITION(LogicalOr);
  result = instruction.children.empty();
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto value{assume_value_copy<ValueBoolean>(instruction.value)};
 
  // This boolean value controls whether we should be exhaustive
  if (value) {
    for (const auto &child : instruction.children) {
      // A branch that does not hold contributes nothing, including any
      // evaluation it marked before failing. Only a schema that tracks
      // evaluation can ever observe those marks
      [[maybe_unused]] std::size_t checkpoint{0};
      if constexpr (Track) {
        checkpoint = context.evaluator->checkpoint();
      }
 
      if (EVALUATE_RECURSE(child, target)) {
        result = true;
      } else {
        if constexpr (Track) {
          context.evaluator->rewind(checkpoint);
        }
      }
    }
  } else {
    for (const auto &child : instruction.children) {
      [[maybe_unused]] std::size_t checkpoint{0};
      if constexpr (Track) {
        checkpoint = context.evaluator->checkpoint();
      }
 
      if (EVALUATE_RECURSE(child, target)) {
        result = true;
        break;
      }
 
      if constexpr (Track) {
        context.evaluator->rewind(checkpoint);
      }
    }
  }
 
  EVALUATE_END(LogicalOr);
}
 
INSTRUCTION_HANDLER(LogicalAnd) {
  EVALUATE_BEGIN_NO_PRECONDITION(LogicalAnd);
  result = true;
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  for (const auto &child : instruction.children) {
    if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LogicalAnd);
}
 
INSTRUCTION_HANDLER(LogicalWhenType) {
  const auto value{assume_value_copy<ValueType>(instruction.value)};
 
  // Not having to worry about numbers in this instruction
  // makes things a lot simpler
  assert(value != JSON::Type::Integer);
  SOURCEMETA_ASSUME(value != JSON::Type::Integer);
  assert(value != JSON::Type::Real);
  SOURCEMETA_ASSUME(value != JSON::Type::Real);
  assert(value != JSON::Type::Decimal);
  SOURCEMETA_ASSUME(value != JSON::Type::Decimal);
 
  EVALUATE_BEGIN(LogicalWhenType, target.type() == value);
  result = true;
  for (const auto &child : instruction.children) {
    if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LogicalWhenType);
}
 
INSTRUCTION_HANDLER(LogicalWhenDefines) {
  const auto &value{assume_value<ValueProperty>(instruction.value)};
  EVALUATE_BEGIN_NON_STRING(LogicalWhenDefines,
                            target.is_object() &&
                                target.defines(value.first, value.second));
  result = true;
  for (const auto &child : instruction.children) {
    if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LogicalWhenDefines);
}
 
INSTRUCTION_HANDLER(LogicalWhenArraySizeGreater) {
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  EVALUATE_BEGIN_NON_STRING(LogicalWhenArraySizeGreater,
                            target.is_array() && target.array_size() > value);
  result = true;
  for (const auto &child : instruction.children) {
    if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LogicalWhenArraySizeGreater);
}
 
INSTRUCTION_HANDLER(LogicalXor) {
  EVALUATE_BEGIN_NO_PRECONDITION(LogicalXor);
  result = true;
  bool has_matched{false};
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto value{assume_value_copy<ValueBoolean>(instruction.value)};
  for (const auto &child : instruction.children) {
    // A branch that does not hold contributes nothing, including any
    // evaluation it marked before failing
    [[maybe_unused]] std::size_t checkpoint{0};
    if constexpr (Track) {
      checkpoint = context.evaluator->checkpoint();
    }
 
    if (EVALUATE_RECURSE(child, target)) {
      if (has_matched) [[unlikely]] {
        result = false;
        // This boolean value controls whether we should be exhaustive
        if (!value) {
          break;
        }
      } else {
        has_matched = true;
      }
    } else {
      if constexpr (Track) {
        context.evaluator->rewind(checkpoint);
      }
    }
  }
 
  result = result && has_matched;
  EVALUATE_END(LogicalXor);
}
 
INSTRUCTION_HANDLER(LogicalCondition) {
  EVALUATE_BEGIN_NO_PRECONDITION(LogicalCondition);
  result = true;
  const auto value{assume_value_copy<ValueIndexPair>(instruction.value)};
  const auto children_size{instruction.children.size()};
  assert(children_size >= value.first);
  SOURCEMETA_ASSUME(children_size >= value.first);
  assert(children_size >= value.second);
  SOURCEMETA_ASSUME(children_size >= value.second);
 
  // The condition is the leading segment [0, then start). It may be empty,
  // for example when a `$ref` condition inlines and its jump is dropped, in
  // which case it trivially passes and the then branch applies
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
 
  // A condition that holds does contribute the evaluation it marked, but one
  // that does not hold contributes nothing at all
  [[maybe_unused]] std::size_t checkpoint{0};
  if constexpr (Track) {
    checkpoint = context.evaluator->checkpoint();
  }
 
  for (std::size_t cursor = 0; cursor < value.first; cursor++) {
    if (!EVALUATE_RECURSE(instruction.children[cursor], target)) {
      result = false;
      break;
    }
  }
 
  if (!result) {
    if constexpr (Track) {
      context.evaluator->rewind(checkpoint);
    }
  }
 
  // On a passing condition the then branch runs, otherwise the else branch,
  // which is absent when it starts at zero
  std::size_t consequence_start;
  std::size_t consequence_end;
  if (result) {
    consequence_start = value.first;
    consequence_end = value.second > 0 ? value.second : children_size;
  } else {
    consequence_start = value.second;
    consequence_end = value.second > 0 ? children_size : value.second;
  }
 
  result = true;
  if (consequence_start < consequence_end) {
    if constexpr (Track || HasCallback) {
      if (track) {
        context.evaluator->evaluate_path.pop_back(
            context.schema->extra[instruction.extra_index]
                .relative_schema_location.size());
      }
    }
 
    for (auto cursor = consequence_start; cursor < consequence_end; cursor++) {
      if (!EVALUATE_RECURSE(instruction.children[cursor], target)) {
        result = false;
        break;
      }
    }
 
    if constexpr (Track || HasCallback) {
      if (track) {
        context.evaluator->evaluate_path.push_back(
            context.schema->extra[instruction.extra_index]
                .relative_schema_location);
      }
    }
  }
 
  EVALUATE_END(LogicalCondition);
}
 
INSTRUCTION_HANDLER(ControlGroup) {
  EVALUATE_BEGIN_PASS_THROUGH(ControlGroup);
  for (const auto &child : instruction.children) {
    if (!EVALUATE_RECURSE(child, instance)) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END_PASS_THROUGH(ControlGroup);
}
 
INSTRUCTION_HANDLER(ControlGroupWhenDefines) {
  EVALUATE_BEGIN_PASS_THROUGH(ControlGroupWhenDefines);
  assert(!instruction.children.empty());
  // Otherwise why are we emitting this property?
  assert(!instruction.relative_instance_location.empty());
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueProperty>(instruction.value)};
  if (target.is_object() && target.defines(value.first, value.second)) {
    for (const auto &child : instruction.children) {
      // Note that in this control instruction, we purposely
      // don't navigate into the target
      if (!EVALUATE_RECURSE(child, instance)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END_PASS_THROUGH(ControlGroupWhenDefines);
}
 
INSTRUCTION_HANDLER(ControlGroupWhenDefinesDirect) {
  EVALUATE_BEGIN_PASS_THROUGH(ControlGroupWhenDefinesDirect);
  assert(!instruction.children.empty());
  assert(instruction.relative_instance_location.empty());
  const auto &value{assume_value<ValueProperty>(instruction.value)};
 
  if (instance.is_object() && instance.defines(value.first, value.second)) {
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, instance)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END_PASS_THROUGH(ControlGroupWhenDefinesDirect);
}
 
INSTRUCTION_HANDLER(ControlGroupWhenType) {
  EVALUATE_BEGIN_PASS_THROUGH(ControlGroupWhenType);
  assert(!instruction.children.empty());
  assert(instruction.relative_instance_location.empty());
  const auto value{assume_value_copy<ValueType>(instruction.value)};
 
  // Not having to worry about numbers in this instruction
  // makes things a lot simpler
  assert(value != JSON::Type::Integer);
  SOURCEMETA_ASSUME(value != JSON::Type::Integer);
  assert(value != JSON::Type::Real);
  SOURCEMETA_ASSUME(value != JSON::Type::Real);
  assert(value != JSON::Type::Decimal);
  SOURCEMETA_ASSUME(value != JSON::Type::Decimal);
 
  if (instance.type() == value) [[likely]] {
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, instance)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END_PASS_THROUGH(ControlGroupWhenType);
}
 
INSTRUCTION_HANDLER(ControlEvaluate) {
  EVALUATE_BEGIN_PASS_THROUGH(ControlEvaluate);
  const auto &value{assume_value<ValuePointer>(instruction.value)};
  context.evaluator->evaluate(&get(instance, value));
  EVALUATE_END_PASS_THROUGH(ControlEvaluate);
}
 
INSTRUCTION_HANDLER(ControlDynamicAnchorJump) {
  EVALUATE_BEGIN_NO_PRECONDITION(ControlDynamicAnchorJump);
  result = false;
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueString>(instruction.value)};
  for (const auto &resource : context.evaluator->resources) {
    const auto label{Evaluator::hash(resource, value)};
    const auto match{std::ranges::find_if(
        context.schema->labels,
        [&label](const auto &entry) -> bool { return entry.first == label; })};
    if (match != context.schema->labels.cend()) [[likely]] {
      result = true;
      assert(match->second < context.schema->targets.size());
      for (const auto &child : context.schema->targets[match->second]) {
        if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
          result = false;
          EVALUATE_END(ControlDynamicAnchorJump);
        }
      }
 
      break;
    }
  }
 
  EVALUATE_END(ControlDynamicAnchorJump);
}
 
INSTRUCTION_HANDLER(ControlJump) {
  EVALUATE_BEGIN_NO_PRECONDITION(ControlJump);
  result = true;
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  assert(context.schema->targets.size() > value);
  const auto &target{resolve_target(
      context.property_target,
      resolve_instance(instance, instruction.relative_instance_location))};
  for (const auto &child : context.schema->targets[value]) {
    if (!EVALUATE_RECURSE(child, target)) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(ControlJump);
}
 
INSTRUCTION_HANDLER(AnnotationEmit) {
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  EVALUATE_ANNOTATION(AnnotationEmit, context.evaluator->instance_location,
                      value);
}
 
INSTRUCTION_HANDLER(AnnotationEmitWrapped) {
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  EVALUATE_ANNOTATION(AnnotationEmitWrapped,
                      context.evaluator->instance_location, value);
}
 
INSTRUCTION_HANDLER(AnnotationToParent) {
  const auto &value{assume_value<ValueJSON>(instruction.value)};
  EVALUATE_ANNOTATION(
      AnnotationToParent,
      // TODO: Can we avoid a copy of the instance location here?
      context.evaluator->instance_location.initial(), value);
}
 
INSTRUCTION_HANDLER(AnnotationBasenameToParent) {
  EVALUATE_ANNOTATION(
      AnnotationBasenameToParent,
      // TODO: Can we avoid a copy of the instance location here?
      context.evaluator->instance_location.initial(),
      context.evaluator->instance_location.back().to_json());
}
 
INSTRUCTION_HANDLER(Evaluate) {
  EVALUATE_BEGIN_NO_PRECONDITION(Evaluate);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  context.evaluator->evaluate(&target);
  result = true;
  EVALUATE_END(Evaluate);
}
 
INSTRUCTION_HANDLER(LogicalNot) {
  EVALUATE_BEGIN_NO_PRECONDITION(LogicalNot);
 
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  for (const auto &child : instruction.children) {
    if (!EVALUATE_RECURSE(child, target)) [[likely]] {
      result = true;
      break;
    }
  }
 
  EVALUATE_END(LogicalNot);
}
 
INSTRUCTION_HANDLER(LogicalNotEvaluate) {
  EVALUATE_BEGIN_NO_PRECONDITION(LogicalNotEvaluate);
 
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  for (const auto &child : instruction.children) {
    if (!EVALUATE_RECURSE(child, target)) [[likely]] {
      result = true;
      break;
    }
  }
 
  context.evaluator->unevaluate();
 
  EVALUATE_END(LogicalNotEvaluate);
}
 
INSTRUCTION_HANDLER(LoopPropertiesUnevaluated) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesUnevaluated, target.is_object());
  assert(!instruction.children.empty());
  result = true;
 
  if (!context.evaluator->is_evaluated(&target)) {
    for (const auto &entry : target.as_object()) {
      if (context.evaluator->is_evaluated(&entry.second)) {
        continue;
      }
 
      if constexpr (HasCallback) {
        context.evaluator->instance_location.push_back(entry.first);
      }
      for (const auto &child : instruction.children) {
        if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
          result = false;
          if constexpr (HasCallback) {
            context.evaluator->instance_location.pop_back();
          }
          EVALUATE_END(LoopPropertiesUnevaluated);
        }
      }
 
      if constexpr (HasCallback) {
        context.evaluator->instance_location.pop_back();
      }
    }
 
    context.evaluator->evaluate(&target);
  }
 
  EVALUATE_END(LoopPropertiesUnevaluated);
}
 
INSTRUCTION_HANDLER(LoopPropertiesUnevaluatedExcept) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesUnevaluatedExcept,
                            target.is_object());
  assert(!instruction.children.empty());
  const auto &value{assume_value<ValuePropertyFilter>(instruction.value)};
  const auto &[filter_strings, filter_prefixes, filter_regexes] = value;
  result = true;
  // Otherwise why emit this instruction?
  assert(!filter_strings.empty() || !filter_prefixes.empty() ||
         !filter_regexes.empty());
 
  if (!context.evaluator->is_evaluated(&target)) {
    for (const auto &entry : target.as_object()) {
      if (filter_strings.contains(entry.first, entry.hash)) {
        continue;
      }
 
      if (std::ranges::any_of(filter_prefixes,
                              [&entry](const auto &prefix) -> bool {
                                return entry.first.starts_with(prefix);
                              })) {
        continue;
      }
 
      if (std::ranges::any_of(filter_regexes,
                              [&entry](const auto &pattern) -> bool {
                                return matches(pattern.first, entry.first);
                              })) {
        continue;
      }
 
      if (context.evaluator->is_evaluated(&entry.second)) {
        continue;
      }
 
      if constexpr (HasCallback) {
        context.evaluator->instance_location.push_back(entry.first);
      }
      for (const auto &child : instruction.children) {
        if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
          result = false;
          if constexpr (HasCallback) {
            context.evaluator->instance_location.pop_back();
          }
          EVALUATE_END(LoopPropertiesUnevaluatedExcept);
        }
      }
 
      if constexpr (HasCallback) {
        context.evaluator->instance_location.pop_back();
      }
    }
 
    context.evaluator->evaluate(&target);
  }
 
  EVALUATE_END(LoopPropertiesUnevaluatedExcept);
}
 
INSTRUCTION_HANDLER(LoopPropertiesMatch) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesMatch, target.is_object());
  const auto &value{assume_value<ValueNamedIndexes>(instruction.value)};
  assert(!value.first.empty());
  result = true;
  // The loop already holds each property's value, so a child that only looks at
  // that value is decided here, rather than dispatched to and left to find the
  // property in the object a second time. The evaluation-marking variants of
  // those assertions are deliberately absent, as skipping them would skip the
  // marker. Dynamic pushes and pops a resource per instruction that the direct
  // path would skip, and children are evaluated at `depth + 1`, which the
  // direct path does not route through the depth check. Every condition holds
  // for every child, so decide once rather than per property
  const auto direct_children{!Track && !HasCallback && !Dynamic &&
                             depth < DEPTH_LIMIT};
  for (const auto &entry : target.as_object()) {
    const auto *index{named_index(value, entry.first, entry.hash)};
    if (!index) {
      continue;
    }
 
    const auto &subinstruction{instruction.children[*index]};
    assert(subinstruction.type ==
           sourcemeta::blaze::InstructionIndex::ControlGroup);
    for (const auto &child : subinstruction.children) {
      bool child_ok;
      // A child whose instance location is not just the matched property is not
      // about the value this loop holds, which inlining a reference into the
      // group can produce, so it resolves its own target as usual
      if (direct_children && child.relative_instance_location.size() == 1)
          [[likely]] {
        switch (child.type) {
          case InstructionIndex::AssertionPropertyTypeStrict:
            child_ok = DIRECT(AssertionTypeStrict, entry.second,
                              assume_value_copy<ValueType>(child.value));
            break;
          case InstructionIndex::AssertionPropertyType:
            child_ok = DIRECT(AssertionType, entry.second,
                              assume_value_copy<ValueType>(child.value));
            break;
          case InstructionIndex::AssertionPropertyTypeStrictAny:
            child_ok = DIRECT(AssertionTypeStrictAny, entry.second,
                              assume_value<ValueTypes>(child.value));
            break;
          default:
            child_ok = EVALUATE_RECURSE(child, target);
            break;
        }
      } else {
        child_ok = EVALUATE_RECURSE(child, target);
      }
 
      if (!child_ok) [[unlikely]] {
        result = false;
        EVALUATE_END(LoopPropertiesMatch);
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesMatch);
}
 
INSTRUCTION_HANDLER(LoopPropertiesMatchClosed) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesMatchClosed, target.is_object());
  const auto &value{assume_value<ValueNamedIndexes>(instruction.value)};
  assert(!value.first.empty());
  result = true;
  // The loop already holds each property's value, so a child that only looks at
  // that value is decided here, rather than dispatched to and left to find the
  // property in the object a second time. The evaluation-marking variants of
  // those assertions are deliberately absent, as skipping them would skip the
  // marker. Dynamic pushes and pops a resource per instruction that the direct
  // path would skip, and children are evaluated at `depth + 1`, which the
  // direct path does not route through the depth check. Every condition holds
  // for every child, so decide once rather than per property
  const auto direct_children{!Track && !HasCallback && !Dynamic &&
                             depth < DEPTH_LIMIT};
  for (const auto &entry : target.as_object()) {
    const auto *index{named_index(value, entry.first, entry.hash)};
    if (!index) [[unlikely]] {
      result = false;
      break;
    }
 
    const auto &subinstruction{instruction.children[*index]};
    assert(subinstruction.type ==
           sourcemeta::blaze::InstructionIndex::ControlGroup);
    for (const auto &child : subinstruction.children) {
      bool child_ok;
      // A child whose instance location is not just the matched property is not
      // about the value this loop holds, which inlining a reference into the
      // group can produce, so it resolves its own target as usual
      if (direct_children && child.relative_instance_location.size() == 1)
          [[likely]] {
        switch (child.type) {
          case InstructionIndex::AssertionPropertyTypeStrict:
            child_ok = DIRECT(AssertionTypeStrict, entry.second,
                              assume_value_copy<ValueType>(child.value));
            break;
          case InstructionIndex::AssertionPropertyType:
            child_ok = DIRECT(AssertionType, entry.second,
                              assume_value_copy<ValueType>(child.value));
            break;
          case InstructionIndex::AssertionPropertyTypeStrictAny:
            child_ok = DIRECT(AssertionTypeStrictAny, entry.second,
                              assume_value<ValueTypes>(child.value));
            break;
          default:
            child_ok = EVALUATE_RECURSE(child, target);
            break;
        }
      } else {
        child_ok = EVALUATE_RECURSE(child, target);
      }
 
      if (!child_ok) [[unlikely]] {
        result = false;
        EVALUATE_END(LoopPropertiesMatchClosed);
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesMatchClosed);
}
 
INSTRUCTION_HANDLER(LoopProperties) {
  EVALUATE_BEGIN_NON_STRING(LoopProperties, target.is_object());
  assert(!instruction.children.empty());
  result = true;
  for (const auto &entry : target.as_object()) {
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(entry.first);
      }
    }
 
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopProperties);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  EVALUATE_END(LoopProperties);
}
 
INSTRUCTION_HANDLER(LoopPropertiesEvaluate) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesEvaluate, target.is_object());
  // The subschema may compile to no children, in which case every property
  // trivially matches and only the evaluation marking below takes effect
  result = true;
  for (const auto &entry : target.as_object()) {
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(entry.first);
      }
    }
 
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopPropertiesEvaluate);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  context.evaluator->evaluate(&target);
  EVALUATE_END(LoopPropertiesEvaluate);
}
 
INSTRUCTION_HANDLER(LoopPropertiesRegex) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesRegex, target.is_object());
  assert(!instruction.children.empty());
  const auto &value{assume_value<ValueRegex>(instruction.value)};
  result = true;
  for (const auto &entry : target.as_object()) {
    if (!matches(value.first, entry.first)) {
      continue;
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(entry.first);
      }
    }
 
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopPropertiesRegex);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesRegex);
}
 
INSTRUCTION_HANDLER(LoopPropertiesRegexClosed) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesRegexClosed, target.is_object());
  result = true;
  const auto &value{assume_value<ValueRegex>(instruction.value)};
  for (const auto &entry : target.as_object()) {
    if (!matches(value.first, entry.first)) [[unlikely]] {
      result = false;
      break;
    }
 
    if (instruction.children.empty()) {
      continue;
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(entry.first);
      }
    }
 
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopPropertiesRegexClosed);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesRegexClosed);
}
 
INSTRUCTION_HANDLER(LoopPropertiesStartsWith) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesStartsWith, target.is_object());
  assert(!instruction.children.empty());
  result = true;
  const auto &value{assume_value<ValueString>(instruction.value)};
  for (const auto &entry : target.as_object()) {
    if (!entry.first.starts_with(value)) {
      continue;
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(entry.first);
      }
    }
 
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopPropertiesStartsWith);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesStartsWith);
}
 
INSTRUCTION_HANDLER(LoopPropertiesExcept) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesExcept, target.is_object());
  assert(!instruction.children.empty());
  result = true;
  const auto &value{assume_value<ValuePropertyFilter>(instruction.value)};
  const auto &[filter_strings, filter_prefixes, filter_regexes] = value;
  // Otherwise why emit this instruction?
  assert(!filter_strings.empty() || !filter_prefixes.empty() ||
         !filter_regexes.empty());
 
  for (const auto &entry : target.as_object()) {
    if (filter_strings.contains(entry.first, entry.hash)) {
      continue;
    }
 
    if (std::ranges::any_of(filter_prefixes,
                            [&entry](const auto &prefix) -> bool {
                              return entry.first.starts_with(prefix);
                            })) {
      continue;
    }
 
    if (std::ranges::any_of(filter_regexes,
                            [&entry](const auto &pattern) -> bool {
                              return matches(pattern.first, entry.first);
                            })) {
      continue;
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(entry.first);
      }
    }
 
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, entry.second)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopPropertiesExcept);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesExcept);
}
 
INSTRUCTION_HANDLER(LoopPropertiesType) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesType, target.is_object());
  result = true;
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  for (const auto &entry : target.as_object()) {
    if (entry.second.type() != value &&
        // In non-strict mode, we consider a real number that represents an
        // integer to be an integer
        (value != JSON::Type::Integer || !entry.second.is_integral()))
        [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LoopPropertiesType);
}
 
INSTRUCTION_HANDLER(LoopPropertiesTypeEvaluate) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesTypeEvaluate, target.is_object());
  result = true;
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  for (const auto &entry : target.as_object()) {
    if (entry.second.type() != value &&
        // In non-strict mode, we consider a real number that represents an
        // integer to be an integer
        (value != JSON::Type::Integer || !entry.second.is_integral()))
        [[unlikely]] {
      result = false;
      EVALUATE_END(LoopPropertiesTypeEvaluate);
    }
  }
 
  context.evaluator->evaluate(&target);
  EVALUATE_END(LoopPropertiesTypeEvaluate);
}
 
INSTRUCTION_HANDLER(LoopPropertiesExactlyTypeStrict) {
  EVALUATE_BEGIN_NO_PRECONDITION(LoopPropertiesExactlyTypeStrict);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  const auto &value{assume_value<ValueTypedProperties>(instruction.value)};
  if (!target.is_object()) [[unlikely]] {
    EVALUATE_END(LoopPropertiesExactlyTypeStrict);
  }
 
  const auto &object{target.as_object()};
  if (object.size() == value.second.size()) [[likely]] {
    // Otherwise why emit this instruction?
    assert(!value.second.empty());
    result = true;
    for (const auto &entry : object) {
      // The property count already matches the required set, so confirming
      // that every property is one of the required names is what makes the
      // object exactly the required set, and the value must be of the type
      if (!value.second.contains(entry.first, entry.hash) ||
          effective_type_strict_real(entry.second) != value.first)
          [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesExactlyTypeStrict);
}
 
INSTRUCTION_HANDLER(LoopPropertiesExactlyTypeStrictHash) {
  EVALUATE_BEGIN_NO_PRECONDITION(LoopPropertiesExactlyTypeStrictHash);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  // TODO: Take advantage of the table of contents structure to speed up checks
  const auto &value{assume_value<ValueTypedHashes>(instruction.value)};
 
  if (!target.is_object()) [[unlikely]] {
    EVALUATE_END(LoopPropertiesExactlyTypeStrictHash);
  }
 
  const auto &object{target.as_object()};
  const auto size{object.size()};
  if (size == value.second.first.size()) [[likely]] {
    // Otherwise why emit this instruction?
    assert(!value.second.first.empty());
 
    // The idea is to first assume the object property ordering and the
    // hashes collection aligns. If they don't we do a full comparison
    // from where we left of.
 
    std::size_t index{0};
    for (const auto &entry : object) {
      if (effective_type_strict_real(entry.second) != value.first) {
        EVALUATE_END(LoopPropertiesExactlyTypeStrictHash);
      }
 
      // A hash match alone does not prove the property is required, as two
      // distinct names can share a hash, so the name itself is confirmed
      if (entry.hash != value.second.first[index].first ||
          entry.first != value.second.first[index].second) {
        break;
      }
 
      index += 1;
    }
 
    result = true;
    if (index < size) {
      auto iterator = object.cbegin();
      // Continue where we left
      std::advance(iterator, index);
      for (; iterator != object.cend(); ++iterator) {
        if (effective_type_strict_real(iterator->second) != value.first) {
          result = false;
          break;
        }
 
        // NOLINTNEXTLINE(modernize-use-ranges)
        if (std::ranges::none_of(value.second.first,
                                 [&iterator](const auto &entry) -> bool {
                                   return entry.first == iterator->hash &&
                                          entry.second == iterator->first;
                                 })) {
          result = false;
          break;
        }
      }
    }
  }
 
  EVALUATE_END(LoopPropertiesExactlyTypeStrictHash);
}
 
INSTRUCTION_HANDLER(LoopPropertiesTypeStrict) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesTypeStrict, target.is_object());
  result = true;
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  for (const auto &entry : target.as_object()) {
    if (effective_type_strict_real(entry.second) != value) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LoopPropertiesTypeStrict);
}
 
INSTRUCTION_HANDLER(LoopPropertiesTypeStrictEvaluate) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesTypeStrictEvaluate,
                            target.is_object());
  result = true;
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  for (const auto &entry : target.as_object()) {
    if (effective_type_strict_real(entry.second) != value) [[unlikely]] {
      result = false;
      EVALUATE_END(LoopPropertiesTypeStrictEvaluate);
    }
  }
 
  context.evaluator->evaluate(&target);
  EVALUATE_END(LoopPropertiesTypeStrictEvaluate);
}
 
INSTRUCTION_HANDLER(LoopPropertiesTypeStrictAny) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesTypeStrictAny, target.is_object());
  result = true;
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
  result = type_set_spans_numbers(value)
               ? object_values_in_type_set<false>(target, value)
               : object_values_in_type_set<true>(target, value);
 
  EVALUATE_END(LoopPropertiesTypeStrictAny);
}
 
INSTRUCTION_HANDLER(LoopPropertiesTypeStrictAnyEvaluate) {
  EVALUATE_BEGIN_NON_STRING(LoopPropertiesTypeStrictAnyEvaluate,
                            target.is_object());
  result = true;
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
  result = type_set_spans_numbers(value)
               ? object_values_in_type_set<false>(target, value)
               : object_values_in_type_set<true>(target, value);
  if (!result) [[unlikely]] {
    EVALUATE_END(LoopPropertiesTypeStrictAnyEvaluate);
  }
 
  context.evaluator->evaluate(&target);
  EVALUATE_END(LoopPropertiesTypeStrictAnyEvaluate);
}
 
INSTRUCTION_HANDLER(LoopKeys) {
  EVALUATE_BEGIN_NON_STRING(LoopKeys, target.is_object());
  assert(!instruction.children.empty());
  result = true;
  for (const auto &entry : target.as_object()) {
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(entry.first);
      }
    }
 
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE_ON_PROPERTY_NAME(child, Evaluator::NULL_VALUE,
                                             entry.first)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopKeys);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  EVALUATE_END(LoopKeys);
}
 
INSTRUCTION_HANDLER(LoopItems) {
  EVALUATE_BEGIN_NON_STRING(LoopItems, target.is_array());
  assert(!instruction.children.empty());
  result = true;
 
  // To avoid index lookups and unnecessary conditionals
  if constexpr (!Track && !HasCallback) {
    // Dynamic pushes and pops a resource per instruction that the direct path
    // would skip, and children are evaluated at `depth + 1`, which the direct
    // path does not route through the depth check. Both conditions hold for
    // every child, so decide once rather than per element
    const auto direct_children{!Dynamic && depth < DEPTH_LIMIT};
    for (const auto &new_instance : target.as_array()) {
      for (const auto &child : instruction.children) {
        bool child_ok;
        if (direct_children) [[likely]] {
          switch (child.type) {
            case InstructionIndex::AssertionTypeArrayBounded:
              child_ok =
                  DIRECT(AssertionTypeArrayBounded,
                         resolve_instance(new_instance,
                                          child.relative_instance_location),
                         assume_value<ValueRange>(child.value));
              break;
            default:
              child_ok = EVALUATE_RECURSE(child, new_instance);
              break;
          }
        } else {
          child_ok = EVALUATE_RECURSE(child, new_instance);
        }
 
        if (!child_ok) [[unlikely]] {
          result = false;
          EVALUATE_END(LoopItems);
        }
      }
    }
  } else {
    for (std::size_t index = 0; index < target.array_size(); index++) {
      if constexpr (HasCallback) {
        if (track) {
          context.evaluator->instance_location.push_back(index);
        }
      }
 
      const auto &new_instance{target.at(index)};
      for (const auto &child : instruction.children) {
        if (!EVALUATE_RECURSE(child, new_instance)) [[unlikely]] {
          result = false;
 
          if constexpr (HasCallback) {
            if (track) {
              context.evaluator->instance_location.pop_back();
            }
          }
 
          EVALUATE_END(LoopItems);
        }
      }
 
      if constexpr (HasCallback) {
        if (track) {
          context.evaluator->instance_location.pop_back();
        }
      }
    }
  }
 
  EVALUATE_END(LoopItems);
}
 
INSTRUCTION_HANDLER(LoopItemsFrom) {
  const auto value{assume_value_copy<ValueUnsignedInteger>(instruction.value)};
  EVALUATE_BEGIN_NON_STRING(LoopItemsFrom,
                            target.is_array() && value < target.array_size());
  assert(!instruction.children.empty());
  result = true;
  for (std::size_t index = value; index < target.array_size(); index++) {
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(index);
      }
    }
 
    const auto &new_instance{target.at(index)};
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, new_instance)) [[unlikely]] {
        result = false;
 
        if constexpr (HasCallback) {
          if (track) {
            context.evaluator->instance_location.pop_back();
          }
        }
 
        EVALUATE_END(LoopItemsFrom);
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
  }
 
  EVALUATE_END(LoopItemsFrom);
}
 
INSTRUCTION_HANDLER(LoopItemsUnevaluated) {
  EVALUATE_BEGIN_NON_STRING(LoopItemsUnevaluated, target.is_array());
  // The subschema may compile to no children, in which case every item
  // trivially matches and only the evaluation marking below takes effect
  result = true;
 
  if (!context.evaluator->is_evaluated(&target)) {
    for (std::size_t index = 0; index < target.array_size(); index++) {
      const auto &new_instance{target.at(index)};
      if (context.evaluator->is_evaluated(&new_instance)) {
        continue;
      }
 
      if constexpr (HasCallback) {
        context.evaluator->instance_location.push_back(index);
      }
      for (const auto &child : instruction.children) {
        if (!EVALUATE_RECURSE(child, new_instance)) [[unlikely]] {
          result = false;
          if constexpr (HasCallback) {
            context.evaluator->instance_location.pop_back();
          }
          EVALUATE_END(LoopItemsUnevaluated);
        }
      }
 
      if constexpr (HasCallback) {
        context.evaluator->instance_location.pop_back();
      }
    }
 
    context.evaluator->evaluate(&target);
  }
 
  EVALUATE_END(LoopItemsUnevaluated);
}
 
INSTRUCTION_HANDLER(LoopItemsType) {
  EVALUATE_BEGIN_NON_STRING(LoopItemsType, target.is_array());
  result = true;
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  for (const auto &entry : target.as_array()) {
    if (entry.type() != value &&
        // In non-strict mode, we consider a real number that represents an
        // integer to be an integer
        (value != JSON::Type::Integer || !entry.is_integral())) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LoopItemsType);
}
 
INSTRUCTION_HANDLER(LoopItemsTypeStrict) {
  EVALUATE_BEGIN_NON_STRING(LoopItemsTypeStrict, target.is_array());
  result = true;
  const auto value{assume_value_copy<ValueType>(instruction.value)};
  for (const auto &entry : target.as_array()) {
    if (effective_type_strict_real(entry) != value) [[unlikely]] {
      result = false;
      break;
    }
  }
 
  EVALUATE_END(LoopItemsTypeStrict);
}
 
INSTRUCTION_HANDLER(LoopItemsTypeStrictAny) {
  EVALUATE_BEGIN_NON_STRING(LoopItemsTypeStrictAny, target.is_array());
  const auto value{assume_value_copy<ValueTypes>(instruction.value)};
  assert(value.any());
 
  result = type_set_spans_numbers(value)
               ? array_items_in_type_set<false>(target, value)
               : array_items_in_type_set<true>(target, value);
 
  EVALUATE_END(LoopItemsTypeStrictAny);
}
 
INSTRUCTION_HANDLER(LoopItemsPropertiesExactlyTypeStrictHash) {
  EVALUATE_BEGIN_NO_PRECONDITION(LoopItemsPropertiesExactlyTypeStrictHash);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  // TODO: Take advantage of the table of contents structure to speed up checks
  const auto &value{assume_value<ValueTypedHashes>(instruction.value)};
  // Otherwise why emit this instruction?
  assert(!value.second.first.empty());
 
  result = true;
 
  if (!target.is_array()) [[unlikely]] {
    EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
  }
 
  const auto hashes_size{value.second.first.size()};
  for (const auto &item : target.as_array()) {
    if (!item.is_object()) [[unlikely]] {
      result = false;
      EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
    }
 
    const auto &object{item.as_object()};
    const auto size{object.size()};
    if (size != hashes_size) [[unlikely]] {
      result = false;
      EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
    }
 
    // Unroll, for performance reasons, for small collections. A perfect hash
    // records the key's size, which the compiler requires of every key here,
    // so matching one proves the keys equal
    if (hashes_size == 3) {
      for (const auto &entry : object) {
        if (effective_type_strict_real(entry.second) != value.first)
            // NOLINTNEXTLINE(bugprone-branch-clone)
            [[unlikely]] {
          result = false;
          EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
        } else if (!(entry.hash == value.second.first[0].first ||
                     entry.hash == value.second.first[1].first ||
                     entry.hash == value.second.first[2].first)) {
          result = false;
          EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
        }
      }
    } else if (hashes_size == 2) {
      for (const auto &entry : object) {
        if (effective_type_strict_real(entry.second) != value.first)
            // NOLINTNEXTLINE(bugprone-branch-clone)
            [[unlikely]] {
          result = false;
          EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
        } else if (!(entry.hash == value.second.first[0].first ||
                     entry.hash == value.second.first[1].first)) {
          result = false;
          EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
        }
      }
    } else if (hashes_size == 1) {
      const auto &entry{*object.cbegin()};
      if (effective_type_strict_real(entry.second) != value.first ||
          entry.hash != value.second.first[0].first) [[unlikely]] {
        result = false;
        EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
      }
    } else {
      std::size_t index{0};
      for (const auto &entry : object) {
        if (effective_type_strict_real(entry.second) != value.first)
            // NOLINTNEXTLINE(bugprone-branch-clone)
            [[unlikely]] {
          result = false;
          EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
        } else if (entry.hash == value.second.first[index].first) {
          index += 1;
          continue;
        } else if (!std::ranges::any_of(
                       value.second.first,
                       [&entry](const auto &hash_entry) -> bool {
                         return hash_entry.first == entry.hash;
                       })) {
          result = false;
          EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
        } else {
          index += 1;
        }
      }
    }
  }
 
  EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash);
}
 
INSTRUCTION_HANDLER(LoopItemsPropertiesExactlyTypeStrictHash3) {
  EVALUATE_BEGIN_NO_PRECONDITION(LoopItemsPropertiesExactlyTypeStrictHash3);
  const auto &target{
      resolve_instance(instance, instruction.relative_instance_location)};
  // TODO: Take advantage of the table of contents structure to speed up checks
  const auto &value{assume_value<ValueTypedHashes>(instruction.value)};
  assert(value.second.first.size() == 3);
  // Otherwise why emit this instruction?
  assert(!value.second.first.empty());
 
  if (!target.is_array()) [[unlikely]] {
    result = true;
    EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash3);
  }
 
  for (const auto &item : target.as_array()) {
    if (!item.is_object()) [[unlikely]] {
      EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash3);
    }
 
    const auto &object{item.as_object()};
    if (object.size() != 3) [[unlikely]] {
      EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash3);
    }
 
    const auto &value_1{object.at(0)};
    const auto &value_2{object.at(1)};
    const auto &value_3{object.at(2)};
 
    if (effective_type_strict_real(value_1.second) != value.first ||
        effective_type_strict_real(value_2.second) != value.first ||
        effective_type_strict_real(value_3.second) != value.first)
        [[unlikely]] {
      EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash3);
    }
 
    // A perfect hash records the key's size, which the compiler requires of
    // every key here, so matching one proves the keys equal and the unrolled
    // permutation check compares nothing but hashes
    if ((value_1.hash == value.second.first[0].first &&
         value_2.hash == value.second.first[1].first &&
         value_3.hash == value.second.first[2].first) ||
        (value_1.hash == value.second.first[0].first &&
         value_2.hash == value.second.first[2].first &&
         value_3.hash == value.second.first[1].first) ||
        (value_1.hash == value.second.first[1].first &&
         value_2.hash == value.second.first[0].first &&
         value_3.hash == value.second.first[2].first) ||
        (value_1.hash == value.second.first[1].first &&
         value_2.hash == value.second.first[2].first &&
         value_3.hash == value.second.first[0].first) ||
        (value_1.hash == value.second.first[2].first &&
         value_2.hash == value.second.first[0].first &&
         value_3.hash == value.second.first[1].first) ||
        (value_1.hash == value.second.first[2].first &&
         value_2.hash == value.second.first[1].first &&
         value_3.hash == value.second.first[0].first)) {
      continue;
    }
    EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash3);
  }
 
  result = true;
  EVALUATE_END(LoopItemsPropertiesExactlyTypeStrictHash3);
}
 
INSTRUCTION_DIRECT_COPY(LoopItemsIntegerBounded, ValueIntegerBounds) {
  if (!target.is_array() || target.empty()) {
    return true;
  }
  for (const auto &element : target.as_array()) {
    if (!element.is_number()) [[unlikely]] {
      return false;
    }
 
    if (element.is_integer()) {
      const auto integer{element.to_integer()};
      if (integer < value.first || integer > value.second) [[unlikely]] {
        return false;
      }
    } else if (element.is_real()) {
      const auto real{element.to_real()};
      if (real < static_cast<double>(value.first) ||
          real > static_cast<double>(value.second)) [[unlikely]] {
        return false;
      }
    } else {
      const auto real{element.to_decimal().to_double()};
      if (real < static_cast<double>(value.first) ||
          real > static_cast<double>(value.second)) [[unlikely]] {
        return false;
      }
    }
  }
  return true;
}
 
INSTRUCTION_HANDLER(LoopItemsIntegerBounded) {
  EVALUATE_BEGIN_NON_STRING(LoopItemsIntegerBounded,
                            target.is_array() && !target.empty());
  result = DIRECT(LoopItemsIntegerBounded, target,
                  assume_value_copy<ValueIntegerBounds>(instruction.value));
  EVALUATE_END(LoopItemsIntegerBounded);
}
 
INSTRUCTION_HANDLER(LoopItemsIntegerBoundedSized) {
  const auto &value{
      assume_value<ValueIntegerBoundsWithSize>(instruction.value)};
  const auto &integer_bounds{value.first};
  const auto minimum_size{std::get<0>(value.second)};
  const auto &maximum_size{std::get<1>(value.second)};
  EVALUATE_BEGIN_NON_STRING(LoopItemsIntegerBoundedSized, true);
  if (!target.is_array() || target.array_size() < minimum_size ||
      (maximum_size.has_value() &&
       target.array_size() > maximum_size.value())) {
    EVALUATE_END(LoopItemsIntegerBoundedSized);
  }
 
  result = true;
  for (const auto &element : target.as_array()) {
    if (!element.is_number()) [[unlikely]] {
      result = false;
      break;
    }
 
    if (element.is_integer()) {
      const auto integer{element.to_integer()};
      if (integer < integer_bounds.first || integer > integer_bounds.second)
          [[unlikely]] {
        result = false;
        break;
      }
    } else if (element.is_real()) {
      const auto real{element.to_real()};
      if (real < static_cast<double>(integer_bounds.first) ||
          real > static_cast<double>(integer_bounds.second)) [[unlikely]] {
        result = false;
        break;
      }
    } else {
      const auto real{element.to_decimal().to_double()};
      if (real < static_cast<double>(integer_bounds.first) ||
          real > static_cast<double>(integer_bounds.second)) [[unlikely]] {
        result = false;
        break;
      }
    }
  }
 
  EVALUATE_END(LoopItemsIntegerBoundedSized);
}
 
// `items` whose subschema is itself an `items` with a size bound compiles to a
// loop whose body is two instructions that both only look at the item, which
// means a dispatch per item of the outer array. Nesting the two loops here
// decides the whole shape in one instruction instead
INSTRUCTION_HANDLER(LoopItemsArrayBoundedTypeStrictAny) {
  EVALUATE_BEGIN_NON_STRING(LoopItemsArrayBoundedTypeStrictAny,
                            target.is_array());
  const auto &value{assume_value<ValueTypesWithSize>(instruction.value)};
  const auto types{value.first};
  const auto minimum{std::get<0>(value.second)};
  const auto &maximum{std::get<1>(value.second)};
  assert(types.any());
  // Require early breaking
  assert(!std::get<2>(value.second));
  result = type_set_spans_numbers(types)
               ? items_are_bounded_arrays_in_type_set<false>(target, types,
                                                             minimum, maximum)
               : items_are_bounded_arrays_in_type_set<true>(target, types,
                                                            minimum, maximum);
 
  EVALUATE_END(LoopItemsArrayBoundedTypeStrictAny);
}
 
INSTRUCTION_HANDLER(LoopContains) {
  EVALUATE_BEGIN_NON_STRING(LoopContains, target.is_array());
  // The subschema may compile to no children, in which case every array
  // element trivially matches and the range check alone decides the result
  const auto &value{assume_value<ValueRange>(instruction.value)};
  const auto &[minimum, maximum, is_exhaustive] = value;
  // Note that the range may be unsatisfiable, as `minContains` and
  // `maxContains` are free to invert it, in which case no array matches
  result = minimum == 0;
  auto match_count{
      std::numeric_limits<std::remove_cvref_t<decltype(minimum)>>::min()};
 
  for (std::size_t index = 0; index < target.array_size(); index++) {
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.push_back(index);
      }
    }
 
    const auto &new_instance{target.at(index)};
    bool subresult{true};
    for (const auto &child : instruction.children) {
      if (!EVALUATE_RECURSE(child, new_instance)) {
        subresult = false;
        break;
      }
    }
 
    if constexpr (HasCallback) {
      if (track) {
        context.evaluator->instance_location.pop_back();
      }
    }
 
    if (subresult) {
      match_count += 1;
 
      // Exceeding the upper bound is definitely a failure
      if (maximum.has_value() && match_count > maximum.value()) {
        result = false;
 
        // Note that here we don't want to consider whether to run
        // exhaustively or not. At this point, its already a failure,
        // and anything that comes after would not run at all anyway
        break;
      }
 
      if (match_count >= minimum) {
        result = true;
 
        // Exceeding the lower bound when there is no upper bound
        // is definitely a success
        if (!maximum.has_value() && !is_exhaustive) {
          break;
        }
      }
    }
  }
 
  EVALUATE_END(LoopContains);
}
// NOLINTEND(readability-identifier-naming)
 
#undef INSTRUCTION_HANDLER
 
template <bool Track, bool Dynamic, bool HasCallback>
using DispatchHandler = bool (*)(
    const sourcemeta::blaze::Instruction &, const sourcemeta::core::JSON &,
    std::uint64_t, DispatchContext<Track, Dynamic, HasCallback> &);
 
template <bool Track, bool Dynamic, bool HasCallback>
// Must have same order as InstructionIndex
// NOLINTNEXTLINE(modernize-avoid-c-arrays)
static constexpr DispatchHandler<Track, Dynamic, HasCallback> HANDLERS[105] = {
    AssertionFail,
    AssertionDefines,
    AssertionDefinesStrict,
    AssertionDefinesAll,
    AssertionDefinesAllStrict,
    AssertionDefinesExactly,
    AssertionDefinesExactlyStrict,
    AssertionDefinesExactlyStrictHash3,
    AssertionPropertyDependencies,
    AssertionType,
    AssertionTypeAny,
    AssertionTypeStrict,
    AssertionTypeStrictAny,
    AssertionNotTypeStrictAny,
    AssertionTypeStringBounded,
    AssertionTypeStringUpper,
    AssertionTypeArrayBounded,
    AssertionTypeArrayUpper,
    AssertionTypeObjectBounded,
    AssertionTypeObjectUpper,
    AssertionRegex,
    AssertionStringSizeLess,
    AssertionStringSizeGreater,
    AssertionArraySizeLess,
    AssertionArraySizeGreater,
    AssertionObjectSizeLess,
    AssertionObjectSizeGreater,
    AssertionEqual,
    AssertionEqualsAny,
    AssertionEqualsAnyStringHash,
    AssertionGreaterEqual,
    AssertionLessEqual,
    AssertionGreater,
    AssertionLess,
    AssertionUnique,
    AssertionDivisible,
    AssertionTypeIntegerBounded,
    AssertionTypeIntegerBoundedStrict,
    AssertionTypeIntegerLowerBound,
    AssertionTypeIntegerLowerBoundStrict,
    AssertionNumberIntegerBounded,
    AssertionNumberType,
    AssertionStringType,
    AssertionPropertyType,
    AssertionPropertyTypeEvaluate,
    AssertionPropertyTypeStrict,
    AssertionPropertyTypeStrictEvaluate,
    AssertionPropertyTypeStrictAny,
    AssertionPropertyTypeStrictAnyEvaluate,
    AssertionPropertyEqual,
    AssertionArrayPrefix,
    AssertionArrayPrefixEvaluate,
    AssertionObjectPropertiesSimple,
    AnnotationEmit,
    AnnotationEmitWrapped,
    AnnotationToParent,
    AnnotationBasenameToParent,
    Evaluate,
    LogicalNot,
    LogicalNotEvaluate,
    LogicalOr,
    LogicalAnd,
    LogicalXor,
    LogicalCondition,
    LogicalWhenType,
    LogicalWhenDefines,
    LogicalWhenArraySizeGreater,
    LoopPropertiesUnevaluated,
    LoopPropertiesUnevaluatedExcept,
    LoopPropertiesMatch,
    LoopPropertiesMatchClosed,
    LoopProperties,
    LoopPropertiesEvaluate,
    LoopPropertiesRegex,
    LoopPropertiesRegexClosed,
    LoopPropertiesStartsWith,
    LoopPropertiesExcept,
    LoopPropertiesType,
    LoopPropertiesTypeEvaluate,
    LoopPropertiesExactlyTypeStrict,
    LoopPropertiesExactlyTypeStrictHash,
    LoopPropertiesTypeStrict,
    LoopPropertiesTypeStrictEvaluate,
    LoopPropertiesTypeStrictAny,
    LoopPropertiesTypeStrictAnyEvaluate,
    LoopKeys,
    LoopItems,
    LoopItemsFrom,
    LoopItemsUnevaluated,
    LoopItemsType,
    LoopItemsTypeStrict,
    LoopItemsTypeStrictAny,
    LoopItemsPropertiesExactlyTypeStrictHash,
    LoopItemsPropertiesExactlyTypeStrictHash3,
    LoopItemsIntegerBounded,
    LoopItemsIntegerBoundedSized,
    LoopItemsArrayBoundedTypeStrictAny,
    LoopContains,
    ControlGroup,
    ControlGroupWhenDefines,
    ControlGroupWhenDefinesDirect,
    ControlGroupWhenType,
    ControlEvaluate,
    ControlDynamicAnchorJump,
    ControlJump};
 
template <bool Track, bool Dynamic, bool HasCallback>
inline auto
evaluate_instruction(const sourcemeta::blaze::Instruction &instruction,
                     const sourcemeta::core::JSON &instance,
                     const std::uint64_t depth,
                     DispatchContext<Track, Dynamic, HasCallback> &context)
    -> bool {
  if (depth > DEPTH_LIMIT) [[unlikely]] {
    throw EvaluationError("The evaluation path depth limit was reached "
                          "likely due to infinite recursion");
  }
 
  return HANDLERS<Track, Dynamic, HasCallback>[std::to_underlying(
      instruction.type)](instruction, instance, depth, context);
}
 
template <bool Track, bool Dynamic, bool HasCallback>
inline auto evaluate_instruction_without_callback(
    const sourcemeta::blaze::Instruction &instruction,
    const sourcemeta::core::JSON &instance, const std::uint64_t depth,
    DispatchContext<Track, Dynamic, HasCallback> &context) -> bool {
  if (depth > DEPTH_LIMIT) [[unlikely]] {
    throw EvaluationError("The evaluation path depth limit was reached "
                          "likely due to infinite recursion");
  }
 
  DispatchContext<false, Dynamic, false> plain_context{
      context.schema, context.callback, context.evaluator,
      context.property_target};
  return HANDLERS<false, Dynamic, false>[std::to_underlying(instruction.type)](
      instruction, instance, depth, plain_context);
}
 
template <bool Track, bool Dynamic, bool HasCallback>
inline auto evaluate_instruction_with_property(
    const sourcemeta::blaze::Instruction &instruction,
    const sourcemeta::core::JSON &instance, const std::uint64_t depth,
    DispatchContext<Track, Dynamic, HasCallback> &context,
    const sourcemeta::core::JSON::String &name) -> bool {
  const auto *previous = context.property_target;
  context.property_target = &name;
  const auto result =
      evaluate_instruction(instruction, instance, depth, context);
  context.property_target = previous;
  return result;
}
 
} // namespace sourcemeta::blaze::dispatch
 
#undef EVALUATE_PUSH
#undef EVALUATE_POP
#undef EVALUATE_BEGIN
#undef EVALUATE_BEGIN_NON_STRING
#undef EVALUATE_BEGIN_IF_STRING
#undef EVALUATE_BEGIN_TRY_TARGET
#undef EVALUATE_BEGIN_NO_PRECONDITION
#undef EVALUATE_BEGIN_NO_PRECONDITION_AND_NO_PUSH
#undef EVALUATE_BEGIN_PASS_THROUGH
#undef EVALUATE_END
#undef EVALUATE_END_NO_POP
#undef EVALUATE_END_PASS_THROUGH
#undef EVALUATE_ANNOTATION
#undef EVALUATE_RECURSE
#undef EVALUATE_RECURSE_ON_PROPERTY_NAME
#undef SOURCEMETA_ASSUME
#undef SOURCEMETA_STRINGIFY
 
#endif