// Copyright 2024 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

////////////////////////////////////////////////////////////////////////////////
// File generated by 'tools/src/cmd/gen' using the template:
//   src/tint/lang/glsl/intrinsic/data.cc.tmpl
//
// To regenerate run: './tools/run gen'
//
//                       Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////

#include <limits>
#include <string>

#include "src/tint/lang/core/intrinsic/type_matchers.h"
#include "src/tint/lang/glsl/intrinsic/dialect.h"
#include "src/tint/utils/text/string_stream.h"

namespace tint::glsl::intrinsic {

using namespace tint::core::intrinsic;  // NOLINT(build/namespaces)

namespace {

using ConstEvalFunctionIndex = tint::core::intrinsic::ConstEvalFunctionIndex;
using IntrinsicInfo = tint::core::intrinsic::IntrinsicInfo;
using MatcherIndicesIndex = tint::core::intrinsic::MatcherIndicesIndex;
using MatchState = tint::core::intrinsic::MatchState;
using Number = tint::core::intrinsic::Number;
using NumberMatcher = tint::core::intrinsic::NumberMatcher;
using NumberMatcherIndex = tint::core::intrinsic::NumberMatcherIndex;
using OverloadFlag = tint::core::intrinsic::OverloadFlag;
using OverloadFlags = tint::core::intrinsic::OverloadFlags;
using OverloadIndex = tint::core::intrinsic::OverloadIndex;
using OverloadInfo = tint::core::intrinsic::OverloadInfo;
using ParameterIndex = tint::core::intrinsic::ParameterIndex;
using ParameterInfo = tint::core::intrinsic::ParameterInfo;
using StringStream = tint::StringStream;
using TemplateIndex = tint::core::intrinsic::TemplateIndex;
using Type = tint::core::type::Type;
using TypeMatcher = tint::core::intrinsic::TypeMatcher;
using TypeMatcherIndex = tint::core::intrinsic::TypeMatcherIndex;

template <size_t N>
using TemplateNumberMatcher = tint::core::intrinsic::TemplateNumberMatcher<N>;

template <size_t N>
using TemplateTypeMatcher = tint::core::intrinsic::TemplateTypeMatcher<N>;

// clang-format off

/// TypeMatcher for 'type bool'
constexpr TypeMatcher kBoolMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchBool(state, ty)) {
      return nullptr;
    }
    return BuildBool(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("bool");
  }
};


/// TypeMatcher for 'type f16'
constexpr TypeMatcher kF16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchF16(state, ty)) {
      return nullptr;
    }
    return BuildF16(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("f16");
  }
};


/// TypeMatcher for 'type f32'
constexpr TypeMatcher kF32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchF32(state, ty)) {
      return nullptr;
    }
    return BuildF32(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("f32");
  }
};


/// TypeMatcher for 'type i32'
constexpr TypeMatcher kI32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchI32(state, ty)) {
      return nullptr;
    }
    return BuildI32(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("i32");
  }
};


/// TypeMatcher for 'type u32'
constexpr TypeMatcher kU32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchU32(state, ty)) {
      return nullptr;
    }
    return BuildU32(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("u32");
  }
};


/// TypeMatcher for 'type atomic'
constexpr TypeMatcher kAtomicMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchAtomic(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildAtomic(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("atomic", "<", T, ">");
  }
};


/// TypeMatcher for 'type ptr'
constexpr TypeMatcher kPtrMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number S = Number::invalid;
  const Type* T = nullptr;
  Number A = Number::invalid;
    if (!MatchPtr(state, ty, S, T, A)) {
      return nullptr;
    }
    S = state.Num(S);
    if (!S.IsValid()) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    A = state.Num(A);
    if (!A.IsValid()) {
      return nullptr;
    }
    return BuildPtr(state, ty, S, T, A);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText S;
  state->PrintNum(S);StyledText T;
  state->PrintType(T);StyledText A;
  state->PrintNum(A);
    out << style::Type("ptr", "<", S, ", ", T, ", ", A, ">");
  }
};


/// TypeMatcher for 'type vec2'
constexpr TypeMatcher kVec2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchVec2(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildVec2(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("vec2", "<", T, ">");
  }
};


/// TypeMatcher for 'type vec3'
constexpr TypeMatcher kVec3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchVec3(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildVec3(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("vec3", "<", T, ">");
  }
};


/// TypeMatcher for 'type vec4'
constexpr TypeMatcher kVec4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchVec4(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildVec4(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("vec4", "<", T, ">");
  }
};


/// TypeMatcher for 'type vec'
constexpr TypeMatcher kVecMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number N = Number::invalid;
  const Type* T = nullptr;
    if (!MatchVec(state, ty, N, T)) {
      return nullptr;
    }
    N = state.Num(N);
    if (!N.IsValid()) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildVec(state, ty, N, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText N;
  state->PrintNum(N);StyledText T;
  state->PrintType(T);
    out << style::Type("vec", N, "<", T, ">");
  }
};


/// TypeMatcher for 'type array'
constexpr TypeMatcher kArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchArray(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildArray(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("array", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_1d'
constexpr TypeMatcher kTexture1DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchTexture1D(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildTexture1D(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("texture_1d", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_2d'
constexpr TypeMatcher kTexture2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchTexture2D(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildTexture2D(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("texture_2d", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_2d_array'
constexpr TypeMatcher kTexture2DArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchTexture2DArray(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildTexture2DArray(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("texture_2d_array", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_3d'
constexpr TypeMatcher kTexture3DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchTexture3D(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildTexture3D(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("texture_3d", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_cube'
constexpr TypeMatcher kTextureCubeMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchTextureCube(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildTextureCube(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("texture_cube", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_cube_array'
constexpr TypeMatcher kTextureCubeArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchTextureCubeArray(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildTextureCubeArray(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("texture_cube_array", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_multisampled_2d'
constexpr TypeMatcher kTextureMultisampled2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchTextureMultisampled2D(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildTextureMultisampled2D(state, ty, T);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T;
  state->PrintType(T);
    out << style::Type("texture_multisampled_2d", "<", T, ">");
  }
};


/// TypeMatcher for 'type texture_depth_2d'
constexpr TypeMatcher kTextureDepth2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchTextureDepth2D(state, ty)) {
      return nullptr;
    }
    return BuildTextureDepth2D(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("texture_depth_2d");
  }
};


/// TypeMatcher for 'type texture_depth_2d_array'
constexpr TypeMatcher kTextureDepth2DArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchTextureDepth2DArray(state, ty)) {
      return nullptr;
    }
    return BuildTextureDepth2DArray(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("texture_depth_2d_array");
  }
};


/// TypeMatcher for 'type texture_depth_cube'
constexpr TypeMatcher kTextureDepthCubeMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchTextureDepthCube(state, ty)) {
      return nullptr;
    }
    return BuildTextureDepthCube(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("texture_depth_cube");
  }
};


/// TypeMatcher for 'type texture_depth_cube_array'
constexpr TypeMatcher kTextureDepthCubeArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchTextureDepthCubeArray(state, ty)) {
      return nullptr;
    }
    return BuildTextureDepthCubeArray(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("texture_depth_cube_array");
  }
};


/// TypeMatcher for 'type texture_depth_multisampled_2d'
constexpr TypeMatcher kTextureDepthMultisampled2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchTextureDepthMultisampled2D(state, ty)) {
      return nullptr;
    }
    return BuildTextureDepthMultisampled2D(state, ty);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {
    out << style::Type("texture_depth_multisampled_2d");
  }
};


/// TypeMatcher for 'type texture_storage_1d'
constexpr TypeMatcher kTextureStorage1DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number F = Number::invalid;
  Number A = Number::invalid;
    if (!MatchTextureStorage1D(state, ty, F, A)) {
      return nullptr;
    }
    F = state.Num(F);
    if (!F.IsValid()) {
      return nullptr;
    }
    A = state.Num(A);
    if (!A.IsValid()) {
      return nullptr;
    }
    return BuildTextureStorage1D(state, ty, F, A);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
  state->PrintNum(F);StyledText A;
  state->PrintNum(A);
    out << style::Type("texture_storage_1d", "<", F, ", ", A, ">");
  }
};


/// TypeMatcher for 'type texture_storage_2d'
constexpr TypeMatcher kTextureStorage2DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number F = Number::invalid;
  Number A = Number::invalid;
    if (!MatchTextureStorage2D(state, ty, F, A)) {
      return nullptr;
    }
    F = state.Num(F);
    if (!F.IsValid()) {
      return nullptr;
    }
    A = state.Num(A);
    if (!A.IsValid()) {
      return nullptr;
    }
    return BuildTextureStorage2D(state, ty, F, A);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
  state->PrintNum(F);StyledText A;
  state->PrintNum(A);
    out << style::Type("texture_storage_2d", "<", F, ", ", A, ">");
  }
};


/// TypeMatcher for 'type texture_storage_2d_array'
constexpr TypeMatcher kTextureStorage2DArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number F = Number::invalid;
  Number A = Number::invalid;
    if (!MatchTextureStorage2DArray(state, ty, F, A)) {
      return nullptr;
    }
    F = state.Num(F);
    if (!F.IsValid()) {
      return nullptr;
    }
    A = state.Num(A);
    if (!A.IsValid()) {
      return nullptr;
    }
    return BuildTextureStorage2DArray(state, ty, F, A);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
  state->PrintNum(F);StyledText A;
  state->PrintNum(A);
    out << style::Type("texture_storage_2d_array", "<", F, ", ", A, ">");
  }
};


/// TypeMatcher for 'type texture_storage_3d'
constexpr TypeMatcher kTextureStorage3DMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number F = Number::invalid;
  Number A = Number::invalid;
    if (!MatchTextureStorage3D(state, ty, F, A)) {
      return nullptr;
    }
    F = state.Num(F);
    if (!F.IsValid()) {
      return nullptr;
    }
    A = state.Num(A);
    if (!A.IsValid()) {
      return nullptr;
    }
    return BuildTextureStorage3D(state, ty, F, A);
  },
/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F;
  state->PrintNum(F);StyledText A;
  state->PrintNum(A);
    out << style::Type("texture_storage_3d", "<", F, ", ", A, ">");
  }
};


/// TypeMatcher for 'match iu32'
constexpr TypeMatcher kIu32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    return nullptr;
  },
/* print */ [](MatchState*, StyledText& out) {
    // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
 kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kU32Matcher.print(nullptr, out);}
};

/// TypeMatcher for 'match fiu32'
constexpr TypeMatcher kFiu32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    return nullptr;
  },
/* print */ [](MatchState*, StyledText& out) {
    // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
 kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kU32Matcher.print(nullptr, out);}
};

/// TypeMatcher for 'match fi32_f16'
constexpr TypeMatcher kFi32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(state, ty);
    }
    return nullptr;
  },
/* print */ [](MatchState*, StyledText& out) {
    // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
 kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);}
};

/// TypeMatcher for 'match fiu32_f16'
constexpr TypeMatcher kFiu32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(state, ty);
    }
    return nullptr;
  },
/* print */ [](MatchState*, StyledText& out) {
    // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
 kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);}
};

/// TypeMatcher for 'match fiu32_f16_bool'
constexpr TypeMatcher kFiu32F16BoolMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(state, ty);
    }
    if (MatchBool(state, ty)) {
      return BuildBool(state, ty);
    }
    return nullptr;
  },
/* print */ [](MatchState*, StyledText& out) {
    // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
 kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);}
};

/// TypeMatcher for 'match f32_f16'
constexpr TypeMatcher kF32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(state, ty);
    }
    return nullptr;
  },
/* print */ [](MatchState*, StyledText& out) {
    // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
 kF32Matcher.print(nullptr, out); out << style::Plain(" or "); kF16Matcher.print(nullptr, out);}
};

/// EnumMatcher for 'match read_write'
constexpr NumberMatcher kReadWriteMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::Access::kReadWrite)) {
      return Number(static_cast<uint32_t>(core::Access::kReadWrite));
    }
    return Number::invalid;
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("read_write");
  }
};

/// EnumMatcher for 'match readable'
constexpr NumberMatcher kReadableMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::Access>(number.Value())) {
      case core::Access::kRead:
      case core::Access::kReadWrite:
        return number;
      default:
        return Number::invalid;
    }
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("read")<< style::Plain(" or ") << style::Enum("read_write");
  }
};

/// EnumMatcher for 'match writable'
constexpr NumberMatcher kWritableMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::Access>(number.Value())) {
      case core::Access::kWrite:
      case core::Access::kReadWrite:
        return number;
      default:
        return Number::invalid;
    }
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("write")<< style::Plain(" or ") << style::Enum("read_write");
  }
};

/// EnumMatcher for 'match workgroup_or_storage'
constexpr NumberMatcher kWorkgroupOrStorageMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::AddressSpace>(number.Value())) {
      case core::AddressSpace::kStorage:
      case core::AddressSpace::kWorkgroup:
        return number;
      default:
        return Number::invalid;
    }
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("storage")<< style::Plain(" or ") << style::Enum("workgroup");
  }
};

/// EnumMatcher for 'match function'
constexpr NumberMatcher kFunctionMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::AddressSpace::kFunction)) {
      return Number(static_cast<uint32_t>(core::AddressSpace::kFunction));
    }
    return Number::invalid;
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("function");
  }
};

/// EnumMatcher for 'match storage'
constexpr NumberMatcher kStorageMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::AddressSpace::kStorage)) {
      return Number(static_cast<uint32_t>(core::AddressSpace::kStorage));
    }
    return Number::invalid;
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("storage");
  }
};

/// EnumMatcher for 'match f32_texel_format'
constexpr NumberMatcher kF32TexelFormatMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::TexelFormat>(number.Value())) {
      case core::TexelFormat::kR8Unorm:
      case core::TexelFormat::kBgra8Unorm:
      case core::TexelFormat::kRgba8Unorm:
      case core::TexelFormat::kRgba8Snorm:
      case core::TexelFormat::kRgba16Float:
      case core::TexelFormat::kR32Float:
      case core::TexelFormat::kRg32Float:
      case core::TexelFormat::kRgba32Float:
        return number;
      default:
        return Number::invalid;
    }
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("r8unorm")<< style::Plain(", ") << style::Enum("bgra8unorm")<< style::Plain(", ") << style::Enum("rgba8unorm")<< style::Plain(", ") << style::Enum("rgba8snorm")<< style::Plain(", ") << style::Enum("rgba16float")<< style::Plain(", ") << style::Enum("r32float")<< style::Plain(", ") << style::Enum("rg32float")<< style::Plain(" or ") << style::Enum("rgba32float");
  }
};

/// EnumMatcher for 'match u32_texel_format'
constexpr NumberMatcher kU32TexelFormatMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::TexelFormat>(number.Value())) {
      case core::TexelFormat::kRgba8Uint:
      case core::TexelFormat::kRgba16Uint:
      case core::TexelFormat::kR32Uint:
      case core::TexelFormat::kRg32Uint:
      case core::TexelFormat::kRgba32Uint:
        return number;
      default:
        return Number::invalid;
    }
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("rgba8uint")<< style::Plain(", ") << style::Enum("rgba16uint")<< style::Plain(", ") << style::Enum("r32uint")<< style::Plain(", ") << style::Enum("rg32uint")<< style::Plain(" or ") << style::Enum("rgba32uint");
  }
};

/// EnumMatcher for 'match i32_texel_format'
constexpr NumberMatcher kI32TexelFormatMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::TexelFormat>(number.Value())) {
      case core::TexelFormat::kRgba8Sint:
      case core::TexelFormat::kRgba16Sint:
      case core::TexelFormat::kR32Sint:
      case core::TexelFormat::kRg32Sint:
      case core::TexelFormat::kRgba32Sint:
        return number;
      default:
        return Number::invalid;
    }
  },
/* print */ [](MatchState*, StyledText& out) {
  out<< style::Enum("rgba8sint")<< style::Plain(", ") << style::Enum("rgba16sint")<< style::Plain(", ") << style::Enum("r32sint")<< style::Plain(", ") << style::Enum("rg32sint")<< style::Plain(" or ") << style::Enum("rgba32sint");
  }
};

/// Type and number matchers

/// The template types, types, and type matchers
constexpr TypeMatcher kTypeMatchers[] = {
  /* [0] */ TemplateTypeMatcher<0>::matcher,
  /* [1] */ TemplateTypeMatcher<1>::matcher,
  /* [2] */ kBoolMatcher,
  /* [3] */ kF16Matcher,
  /* [4] */ kF32Matcher,
  /* [5] */ kI32Matcher,
  /* [6] */ kU32Matcher,
  /* [7] */ kAtomicMatcher,
  /* [8] */ kPtrMatcher,
  /* [9] */ kVec2Matcher,
  /* [10] */ kVec3Matcher,
  /* [11] */ kVec4Matcher,
  /* [12] */ kVecMatcher,
  /* [13] */ kArrayMatcher,
  /* [14] */ kTexture1DMatcher,
  /* [15] */ kTexture2DMatcher,
  /* [16] */ kTexture2DArrayMatcher,
  /* [17] */ kTexture3DMatcher,
  /* [18] */ kTextureCubeMatcher,
  /* [19] */ kTextureCubeArrayMatcher,
  /* [20] */ kTextureMultisampled2DMatcher,
  /* [21] */ kTextureDepth2DMatcher,
  /* [22] */ kTextureDepth2DArrayMatcher,
  /* [23] */ kTextureDepthCubeMatcher,
  /* [24] */ kTextureDepthCubeArrayMatcher,
  /* [25] */ kTextureDepthMultisampled2DMatcher,
  /* [26] */ kTextureStorage1DMatcher,
  /* [27] */ kTextureStorage2DMatcher,
  /* [28] */ kTextureStorage2DArrayMatcher,
  /* [29] */ kTextureStorage3DMatcher,
  /* [30] */ kIu32Matcher,
  /* [31] */ kFiu32Matcher,
  /* [32] */ kFi32F16Matcher,
  /* [33] */ kFiu32F16Matcher,
  /* [34] */ kFiu32F16BoolMatcher,
  /* [35] */ kF32F16Matcher,
};

/// The template numbers, and number matchers
constexpr NumberMatcher kNumberMatchers[] = {
  /* [0] */ TemplateNumberMatcher<0>::matcher,
  /* [1] */ TemplateNumberMatcher<1>::matcher,
  /* [2] */ kReadWriteMatcher,
  /* [3] */ kReadableMatcher,
  /* [4] */ kWritableMatcher,
  /* [5] */ kWorkgroupOrStorageMatcher,
  /* [6] */ kFunctionMatcher,
  /* [7] */ kStorageMatcher,
  /* [8] */ kF32TexelFormatMatcher,
  /* [9] */ kU32TexelFormatMatcher,
  /* [10] */ kI32TexelFormatMatcher,
};

constexpr MatcherIndex kMatcherIndices[] = {
  /* [0] */ MatcherIndex(8),
  /* [1] */ MatcherIndex(6),
  /* [2] */ MatcherIndex(12),
  /* [3] */ MatcherIndex(0),
  /* [4] */ MatcherIndex(1),
  /* [5] */ MatcherIndex(2),
  /* [6] */ MatcherIndex(8),
  /* [7] */ MatcherIndex(6),
  /* [8] */ MatcherIndex(12),
  /* [9] */ MatcherIndex(0),
  /* [10] */ MatcherIndex(5),
  /* [11] */ MatcherIndex(2),
  /* [12] */ MatcherIndex(8),
  /* [13] */ MatcherIndex(7),
  /* [14] */ MatcherIndex(13),
  /* [15] */ MatcherIndex(0),
  /* [16] */ MatcherIndex(1),
  /* [17] */ MatcherIndex(8),
  /* [18] */ MatcherIndex(5),
  /* [19] */ MatcherIndex(7),
  /* [20] */ MatcherIndex(0),
  /* [21] */ MatcherIndex(2),
  /* [22] */ MatcherIndex(8),
  /* [23] */ MatcherIndex(1),
  /* [24] */ MatcherIndex(7),
  /* [25] */ MatcherIndex(0),
  /* [26] */ MatcherIndex(2),
  /* [27] */ MatcherIndex(8),
  /* [28] */ MatcherIndex(6),
  /* [29] */ MatcherIndex(0),
  /* [30] */ MatcherIndex(2),
  /* [31] */ MatcherIndex(8),
  /* [32] */ MatcherIndex(6),
  /* [33] */ MatcherIndex(5),
  /* [34] */ MatcherIndex(2),
  /* [35] */ MatcherIndex(12),
  /* [36] */ MatcherIndex(0),
  /* [37] */ MatcherIndex(4),
  /* [38] */ MatcherIndex(12),
  /* [39] */ MatcherIndex(0),
  /* [40] */ MatcherIndex(6),
  /* [41] */ MatcherIndex(12),
  /* [42] */ MatcherIndex(1),
  /* [43] */ MatcherIndex(5),
  /* [44] */ MatcherIndex(12),
  /* [45] */ MatcherIndex(1),
  /* [46] */ MatcherIndex(0),
  /* [47] */ MatcherIndex(12),
  /* [48] */ MatcherIndex(0),
  /* [49] */ MatcherIndex(2),
  /* [50] */ MatcherIndex(26),
  /* [51] */ MatcherIndex(0),
  /* [52] */ MatcherIndex(1),
  /* [53] */ MatcherIndex(27),
  /* [54] */ MatcherIndex(0),
  /* [55] */ MatcherIndex(1),
  /* [56] */ MatcherIndex(28),
  /* [57] */ MatcherIndex(0),
  /* [58] */ MatcherIndex(1),
  /* [59] */ MatcherIndex(29),
  /* [60] */ MatcherIndex(0),
  /* [61] */ MatcherIndex(1),
  /* [62] */ MatcherIndex(26),
  /* [63] */ MatcherIndex(8),
  /* [64] */ MatcherIndex(4),
  /* [65] */ MatcherIndex(26),
  /* [66] */ MatcherIndex(10),
  /* [67] */ MatcherIndex(4),
  /* [68] */ MatcherIndex(26),
  /* [69] */ MatcherIndex(9),
  /* [70] */ MatcherIndex(4),
  /* [71] */ MatcherIndex(27),
  /* [72] */ MatcherIndex(8),
  /* [73] */ MatcherIndex(4),
  /* [74] */ MatcherIndex(27),
  /* [75] */ MatcherIndex(10),
  /* [76] */ MatcherIndex(4),
  /* [77] */ MatcherIndex(27),
  /* [78] */ MatcherIndex(9),
  /* [79] */ MatcherIndex(4),
  /* [80] */ MatcherIndex(29),
  /* [81] */ MatcherIndex(8),
  /* [82] */ MatcherIndex(4),
  /* [83] */ MatcherIndex(29),
  /* [84] */ MatcherIndex(10),
  /* [85] */ MatcherIndex(4),
  /* [86] */ MatcherIndex(29),
  /* [87] */ MatcherIndex(9),
  /* [88] */ MatcherIndex(4),
  /* [89] */ MatcherIndex(28),
  /* [90] */ MatcherIndex(8),
  /* [91] */ MatcherIndex(4),
  /* [92] */ MatcherIndex(28),
  /* [93] */ MatcherIndex(10),
  /* [94] */ MatcherIndex(4),
  /* [95] */ MatcherIndex(28),
  /* [96] */ MatcherIndex(9),
  /* [97] */ MatcherIndex(4),
  /* [98] */ MatcherIndex(12),
  /* [99] */ MatcherIndex(1),
  /* [100] */ MatcherIndex(2),
  /* [101] */ MatcherIndex(9),
  /* [102] */ MatcherIndex(3),
  /* [103] */ MatcherIndex(14),
  /* [104] */ MatcherIndex(0),
  /* [105] */ MatcherIndex(9),
  /* [106] */ MatcherIndex(5),
  /* [107] */ MatcherIndex(15),
  /* [108] */ MatcherIndex(0),
  /* [109] */ MatcherIndex(10),
  /* [110] */ MatcherIndex(5),
  /* [111] */ MatcherIndex(16),
  /* [112] */ MatcherIndex(0),
  /* [113] */ MatcherIndex(17),
  /* [114] */ MatcherIndex(0),
  /* [115] */ MatcherIndex(18),
  /* [116] */ MatcherIndex(0),
  /* [117] */ MatcherIndex(19),
  /* [118] */ MatcherIndex(0),
  /* [119] */ MatcherIndex(20),
  /* [120] */ MatcherIndex(0),
  /* [121] */ MatcherIndex(11),
  /* [122] */ MatcherIndex(0),
  /* [123] */ MatcherIndex(11),
  /* [124] */ MatcherIndex(4),
  /* [125] */ MatcherIndex(11),
  /* [126] */ MatcherIndex(5),
  /* [127] */ MatcherIndex(11),
  /* [128] */ MatcherIndex(6),
  /* [129] */ MatcherIndex(9),
  /* [130] */ MatcherIndex(0),
  /* [131] */ MatcherIndex(10),
  /* [132] */ MatcherIndex(0),
  /* [133] */ MatcherIndex(30),
  /* [134] */ MatcherIndex(32),
  /* [135] */ MatcherIndex(35),
  /* [136] */ MatcherIndex(31),
  /* [137] */ MatcherIndex(21),
  /* [138] */ MatcherIndex(22),
  /* [139] */ MatcherIndex(23),
  /* [140] */ MatcherIndex(24),
  /* [141] */ MatcherIndex(25),
  /* [142] */ MatcherIndex(33),
  /* [143] */ MatcherIndex(34),
};

static_assert(MatcherIndicesIndex::CanIndex(kMatcherIndices),
              "MatcherIndicesIndex is not large enough to index kMatcherIndices");

constexpr ParameterInfo kParameters[] = {
  {
    /* [0] */
    /* usage */ core::ParameterUsage::kBase,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [1] */
    /* usage */ core::ParameterUsage::kInsert,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [2] */
    /* usage */ core::ParameterUsage::kOffset,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [3] */
    /* usage */ core::ParameterUsage::kBits,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [4] */
    /* usage */ core::ParameterUsage::kBase,
    /* matcher_indices */ MatcherIndicesIndex(44),
  },
  {
    /* [5] */
    /* usage */ core::ParameterUsage::kInsert,
    /* matcher_indices */ MatcherIndicesIndex(44),
  },
  {
    /* [6] */
    /* usage */ core::ParameterUsage::kOffset,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [7] */
    /* usage */ core::ParameterUsage::kBits,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [8] */
    /* usage */ core::ParameterUsage::kNone,
    /* matcher_indices */ MatcherIndicesIndex(17),
  },
  {
    /* [9] */
    /* usage */ core::ParameterUsage::kCompareValue,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [10] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [11] */
    /* usage */ core::ParameterUsage::kOffset,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [12] */
    /* usage */ core::ParameterUsage::kBits,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [13] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(44),
  },
  {
    /* [14] */
    /* usage */ core::ParameterUsage::kOffset,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [15] */
    /* usage */ core::ParameterUsage::kBits,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [16] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(103),
  },
  {
    /* [17] */
    /* usage */ core::ParameterUsage::kLocation,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [18] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [19] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(107),
  },
  {
    /* [20] */
    /* usage */ core::ParameterUsage::kLocation,
    /* matcher_indices */ MatcherIndicesIndex(105),
  },
  {
    /* [21] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [22] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(111),
  },
  {
    /* [23] */
    /* usage */ core::ParameterUsage::kLocation,
    /* matcher_indices */ MatcherIndicesIndex(109),
  },
  {
    /* [24] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [25] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(119),
  },
  {
    /* [26] */
    /* usage */ core::ParameterUsage::kLocation,
    /* matcher_indices */ MatcherIndicesIndex(105),
  },
  {
    /* [27] */
    /* usage */ core::ParameterUsage::kSampleIndex,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [28] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(113),
  },
  {
    /* [29] */
    /* usage */ core::ParameterUsage::kLocation,
    /* matcher_indices */ MatcherIndicesIndex(109),
  },
  {
    /* [30] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [31] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(62),
  },
  {
    /* [32] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [33] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(123),
  },
  {
    /* [34] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(65),
  },
  {
    /* [35] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [36] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(125),
  },
  {
    /* [37] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(68),
  },
  {
    /* [38] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [39] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(127),
  },
  {
    /* [40] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(71),
  },
  {
    /* [41] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(129),
  },
  {
    /* [42] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(123),
  },
  {
    /* [43] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(74),
  },
  {
    /* [44] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(129),
  },
  {
    /* [45] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(125),
  },
  {
    /* [46] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(77),
  },
  {
    /* [47] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(129),
  },
  {
    /* [48] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(127),
  },
  {
    /* [49] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(80),
  },
  {
    /* [50] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(131),
  },
  {
    /* [51] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(123),
  },
  {
    /* [52] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(83),
  },
  {
    /* [53] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(131),
  },
  {
    /* [54] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(125),
  },
  {
    /* [55] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(86),
  },
  {
    /* [56] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(131),
  },
  {
    /* [57] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(127),
  },
  {
    /* [58] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(89),
  },
  {
    /* [59] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(131),
  },
  {
    /* [60] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(123),
  },
  {
    /* [61] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(92),
  },
  {
    /* [62] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(131),
  },
  {
    /* [63] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(125),
  },
  {
    /* [64] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(95),
  },
  {
    /* [65] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(131),
  },
  {
    /* [66] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(127),
  },
  {
    /* [67] */
    /* usage */ core::ParameterUsage::kNone,
    /* matcher_indices */ MatcherIndicesIndex(22),
  },
  {
    /* [68] */
    /* usage */ core::ParameterUsage::kNone,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [69] */
    /* usage */ core::ParameterUsage::kNone,
    /* matcher_indices */ MatcherIndicesIndex(44),
  },
  {
    /* [70] */
    /* usage */ core::ParameterUsage::kNone,
    /* matcher_indices */ MatcherIndicesIndex(44),
  },
  {
    /* [71] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [72] */
    /* usage */ core::ParameterUsage::kResult,
    /* matcher_indices */ MatcherIndicesIndex(27),
  },
  {
    /* [73] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(2),
  },
  {
    /* [74] */
    /* usage */ core::ParameterUsage::kResult,
    /* matcher_indices */ MatcherIndicesIndex(0),
  },
  {
    /* [75] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(3),
  },
  {
    /* [76] */
    /* usage */ core::ParameterUsage::kExp,
    /* matcher_indices */ MatcherIndicesIndex(31),
  },
  {
    /* [77] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(2),
  },
  {
    /* [78] */
    /* usage */ core::ParameterUsage::kExp,
    /* matcher_indices */ MatcherIndicesIndex(6),
  },
  {
    /* [79] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(103),
  },
  {
    /* [80] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [81] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(107),
  },
  {
    /* [82] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [83] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(111),
  },
  {
    /* [84] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [85] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(113),
  },
  {
    /* [86] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [87] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(115),
  },
  {
    /* [88] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [89] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(117),
  },
  {
    /* [90] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [91] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(137),
  },
  {
    /* [92] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [93] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(138),
  },
  {
    /* [94] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [95] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(139),
  },
  {
    /* [96] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [97] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(140),
  },
  {
    /* [98] */
    /* usage */ core::ParameterUsage::kLevel,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [99] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(50),
  },
  {
    /* [100] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [101] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(53),
  },
  {
    /* [102] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(105),
  },
  {
    /* [103] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(56),
  },
  {
    /* [104] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(109),
  },
  {
    /* [105] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(59),
  },
  {
    /* [106] */
    /* usage */ core::ParameterUsage::kCoords,
    /* matcher_indices */ MatcherIndicesIndex(109),
  },
  {
    /* [107] */
    /* usage */ core::ParameterUsage::kNone,
    /* matcher_indices */ MatcherIndicesIndex(12),
  },
  {
    /* [108] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(37),
  },
  {
    /* [109] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(35),
  },
  {
    /* [110] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(10),
  },
  {
    /* [111] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(8),
  },
  {
    /* [112] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(1),
  },
  {
    /* [113] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(38),
  },
  {
    /* [114] */
    /* usage */ core::ParameterUsage::kValue,
    /* matcher_indices */ MatcherIndicesIndex(101),
  },
  {
    /* [115] */
    /* usage */ core::ParameterUsage::kNone,
    /* matcher_indices */ MatcherIndicesIndex(47),
  },
  {
    /* [116] */
    /* usage */ core::ParameterUsage::kTexture,
    /* matcher_indices */ MatcherIndicesIndex(141),
  },
};

static_assert(ParameterIndex::CanIndex(kParameters),
              "ParameterIndex is not large enough to index kParameters");

constexpr TemplateInfo kTemplates[] = {
  {
    /* [0] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [1] */
    /* name */ "A",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [2] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(133),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [3] */
    /* name */ "S",
    /* matcher_indices */ MatcherIndicesIndex(10),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [4] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(133),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [5] */
    /* name */ "N",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [6] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(135),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [7] */
    /* name */ "N",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [8] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(134),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [9] */
    /* name */ "N",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [10] */
    /* name */ "F",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [11] */
    /* name */ "A",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [12] */
    /* name */ "F",
    /* matcher_indices */ MatcherIndicesIndex(0),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [13] */
    /* name */ "A",
    /* matcher_indices */ MatcherIndicesIndex(102),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [14] */
    /* name */ "F",
    /* matcher_indices */ MatcherIndicesIndex(66),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [15] */
    /* name */ "A",
    /* matcher_indices */ MatcherIndicesIndex(102),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [16] */
    /* name */ "F",
    /* matcher_indices */ MatcherIndicesIndex(69),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [17] */
    /* name */ "A",
    /* matcher_indices */ MatcherIndicesIndex(102),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [18] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(142),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [19] */
    /* name */ "N",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [20] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(143),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [21] */
    /* name */ "N",
    /* matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* kind */ TemplateInfo::Kind::kNumber,
  },
  {
    /* [22] */
    /* name */ "T",
    /* matcher_indices */ MatcherIndicesIndex(136),
    /* kind */ TemplateInfo::Kind::kType,
  },
  {
    /* [23] */
    /* name */ "C",
    /* matcher_indices */ MatcherIndicesIndex(133),
    /* kind */ TemplateInfo::Kind::kType,
  },
};

static_assert(TemplateIndex::CanIndex(kTemplates),
              "TemplateIndex is not large enough to index kTemplates");

constexpr core::constant::Eval::Function kConstEvalFunctions[] = {
  /* [0] */ &core::constant::Eval::modf,
  /* [1] */ &core::constant::Eval::frexp,
};

static_assert(ConstEvalFunctionIndex::CanIndex(kConstEvalFunctions),
              "ConstEvalFunctionIndex is not large enough to index kConstEvalFunctions");

constexpr OverloadInfo kOverloads[] = {
  {
    /* [0] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(79),
    /* return_matcher_indices */ MatcherIndicesIndex(10),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [1] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(81),
    /* return_matcher_indices */ MatcherIndicesIndex(105),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [2] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(83),
    /* return_matcher_indices */ MatcherIndicesIndex(109),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [3] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(85),
    /* return_matcher_indices */ MatcherIndicesIndex(109),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [4] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(87),
    /* return_matcher_indices */ MatcherIndicesIndex(105),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [5] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(89),
    /* return_matcher_indices */ MatcherIndicesIndex(109),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [6] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(91),
    /* return_matcher_indices */ MatcherIndicesIndex(105),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [7] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(93),
    /* return_matcher_indices */ MatcherIndicesIndex(109),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [8] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(95),
    /* return_matcher_indices */ MatcherIndicesIndex(105),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [9] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(97),
    /* return_matcher_indices */ MatcherIndicesIndex(109),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [10] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(25),
    /* return_matcher_indices */ MatcherIndicesIndex(105),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [11] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(116),
    /* return_matcher_indices */ MatcherIndicesIndex(105),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [12] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(12),
    /* parameters */ ParameterIndex(99),
    /* return_matcher_indices */ MatcherIndicesIndex(123),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [13] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(12),
    /* parameters */ ParameterIndex(101),
    /* return_matcher_indices */ MatcherIndicesIndex(123),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [14] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(12),
    /* parameters */ ParameterIndex(103),
    /* return_matcher_indices */ MatcherIndicesIndex(123),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [15] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(12),
    /* parameters */ ParameterIndex(105),
    /* return_matcher_indices */ MatcherIndicesIndex(123),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [16] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(14),
    /* parameters */ ParameterIndex(99),
    /* return_matcher_indices */ MatcherIndicesIndex(125),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [17] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(14),
    /* parameters */ ParameterIndex(101),
    /* return_matcher_indices */ MatcherIndicesIndex(125),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [18] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(14),
    /* parameters */ ParameterIndex(103),
    /* return_matcher_indices */ MatcherIndicesIndex(125),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [19] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(14),
    /* parameters */ ParameterIndex(105),
    /* return_matcher_indices */ MatcherIndicesIndex(125),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [20] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(16),
    /* parameters */ ParameterIndex(99),
    /* return_matcher_indices */ MatcherIndicesIndex(127),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [21] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(16),
    /* parameters */ ParameterIndex(101),
    /* return_matcher_indices */ MatcherIndicesIndex(127),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [22] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(16),
    /* parameters */ ParameterIndex(103),
    /* return_matcher_indices */ MatcherIndicesIndex(127),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [23] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(16),
    /* parameters */ ParameterIndex(105),
    /* return_matcher_indices */ MatcherIndicesIndex(127),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [24] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(31),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [25] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(34),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [26] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(37),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [27] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(40),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [28] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(43),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [29] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(46),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [30] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(49),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [31] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(52),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [32] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(55),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [33] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(58),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [34] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(61),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [35] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(23),
    /* parameters */ ParameterIndex(64),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [36] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(16),
    /* return_matcher_indices */ MatcherIndicesIndex(121),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [37] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(19),
    /* return_matcher_indices */ MatcherIndicesIndex(121),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [38] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(22),
    /* return_matcher_indices */ MatcherIndicesIndex(121),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [39] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(25),
    /* return_matcher_indices */ MatcherIndicesIndex(121),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [40] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(22),
    /* parameters */ ParameterIndex(28),
    /* return_matcher_indices */ MatcherIndicesIndex(121),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [41] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(10),
    /* parameters */ ParameterIndex(99),
    /* return_matcher_indices */ MatcherIndicesIndex(10),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [42] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(10),
    /* parameters */ ParameterIndex(101),
    /* return_matcher_indices */ MatcherIndicesIndex(105),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [43] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(10),
    /* parameters */ ParameterIndex(103),
    /* return_matcher_indices */ MatcherIndicesIndex(109),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [44] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(10),
    /* parameters */ ParameterIndex(105),
    /* return_matcher_indices */ MatcherIndicesIndex(109),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [45] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(108),
    /* return_matcher_indices */ MatcherIndicesIndex(10),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [46] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(5),
    /* parameters */ ParameterIndex(109),
    /* return_matcher_indices */ MatcherIndicesIndex(8),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [47] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(108),
    /* return_matcher_indices */ MatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [48] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(5),
    /* parameters */ ParameterIndex(109),
    /* return_matcher_indices */ MatcherIndicesIndex(38),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [49] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(110),
    /* return_matcher_indices */ MatcherIndicesIndex(37),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [50] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(5),
    /* parameters */ ParameterIndex(111),
    /* return_matcher_indices */ MatcherIndicesIndex(35),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [51] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(112),
    /* return_matcher_indices */ MatcherIndicesIndex(37),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [52] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(5),
    /* parameters */ ParameterIndex(113),
    /* return_matcher_indices */ MatcherIndicesIndex(35),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [53] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(2),
    /* parameters */ ParameterIndex(10),
    /* return_matcher_indices */ MatcherIndicesIndex(10),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [54] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(4),
    /* parameters */ ParameterIndex(13),
    /* return_matcher_indices */ MatcherIndicesIndex(41),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [55] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(2),
    /* parameters */ ParameterIndex(10),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [56] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(4),
    /* parameters */ ParameterIndex(13),
    /* return_matcher_indices */ MatcherIndicesIndex(44),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [57] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(2),
    /* parameters */ ParameterIndex(0),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [58] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(4),
    /* parameters */ ParameterIndex(4),
    /* return_matcher_indices */ MatcherIndicesIndex(44),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [59] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(8),
    /* parameters */ ParameterIndex(68),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [60] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(8),
    /* parameters */ ParameterIndex(69),
    /* return_matcher_indices */ MatcherIndicesIndex(44),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [61] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(6),
    /* parameters */ ParameterIndex(71),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(0),
  },
  {
    /* [62] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(5),
    /* parameters */ ParameterIndex(73),
    /* return_matcher_indices */ MatcherIndicesIndex(2),
    /* const_eval_fn */ ConstEvalFunctionIndex(0),
  },
  {
    /* [63] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(6),
    /* parameters */ ParameterIndex(75),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(1),
  },
  {
    /* [64] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(5),
    /* parameters */ ParameterIndex(77),
    /* return_matcher_indices */ MatcherIndicesIndex(2),
    /* const_eval_fn */ ConstEvalFunctionIndex(1),
  },
  {
    /* [65] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse, OverloadFlag::kMemberFunction),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(0),
    /* parameters */ ParameterIndex(107),
    /* return_matcher_indices */ MatcherIndicesIndex(10),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [66] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 0,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [67] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(2),
    /* parameters */ ParameterIndex(8),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [68] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(2),
    /* parameters */ ParameterIndex(67),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [69] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(114),
    /* return_matcher_indices */ MatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [70] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 0,
    /* templates */ TemplateIndex(/* invalid */),
    /* parameters */ ParameterIndex(112),
    /* return_matcher_indices */ MatcherIndicesIndex(101),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [71] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 1,
    /* templates */ TemplateIndex(5),
    /* parameters */ ParameterIndex(115),
    /* return_matcher_indices */ MatcherIndicesIndex(5),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [72] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(6),
    /* parameters */ ParameterIndex(69),
    /* return_matcher_indices */ MatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [73] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(18),
    /* parameters */ ParameterIndex(69),
    /* return_matcher_indices */ MatcherIndicesIndex(98),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [74] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_explicit_templates */ 0,
    /* num_templates   */ 2,
    /* templates */ TemplateIndex(20),
    /* parameters */ ParameterIndex(69),
    /* return_matcher_indices */ MatcherIndicesIndex(98),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
};

static_assert(OverloadIndex::CanIndex(kOverloads),
              "OverloadIndex is not large enough to index kOverloads");

constexpr IntrinsicInfo kBuiltins[] = {
  {
    /* [0] */
    /* fn length[T, A : access](ptr<storage, array<T>, A>) -> i32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(65),
  },
  {
    /* [1] */
    /* fn barrier() */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(66),
  },
  {
    /* [2] */
    /* fn memoryBarrierBuffer() */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(66),
  },
  {
    /* [3] */
    /* fn memoryBarrierImage() */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(66),
  },
  {
    /* [4] */
    /* fn atomicCompSwap[T : iu32](ptr<workgroup_or_storage, atomic<T>, read_write>, compare_value: T, value: T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(67),
  },
  {
    /* [5] */
    /* fn atomicSub[T : iu32, S : workgroup_or_storage](ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(68),
  },
  {
    /* [6] */
    /* fn floatBitsToInt(value: f32) -> i32 */
    /* fn floatBitsToInt[N : num](value: vec<N, f32>) -> vec<N, i32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(45),
  },
  {
    /* [7] */
    /* fn floatBitsToUint(value: f32) -> u32 */
    /* fn floatBitsToUint[N : num](value: vec<N, f32>) -> vec<N, u32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(47),
  },
  {
    /* [8] */
    /* fn intBitsToFloat(value: i32) -> f32 */
    /* fn intBitsToFloat[N : num](value: vec<N, i32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(49),
  },
  {
    /* [9] */
    /* fn uintBitsToFloat(value: u32) -> f32 */
    /* fn uintBitsToFloat[N : num](value: vec<N, u32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(51),
  },
  {
    /* [10] */
    /* fn bitCount[T : iu32](value: T) -> i32 */
    /* fn bitCount[T : iu32, N : num](value: vec<N, T>) -> vec<N, i32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(53),
  },
  {
    /* [11] */
    /* fn bitfieldExtract[T : iu32](value: T, offset: i32, bits: i32) -> T */
    /* fn bitfieldExtract[T : iu32, N : num](value: vec<N, T>, offset: i32, bits: i32) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(55),
  },
  {
    /* [12] */
    /* fn bitfieldInsert[T : iu32](base: T, insert: T, offset: i32, bits: i32) -> T */
    /* fn bitfieldInsert[T : iu32, N : num](base: vec<N, T>, insert: vec<N, T>, offset: i32, bits: i32) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(57),
  },
  {
    /* [13] */
    /* fn packFloat2x16(value: vec2<f16>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(69),
  },
  {
    /* [14] */
    /* fn unpackFloat2x16(value: u32) -> vec2<f16> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(70),
  },
  {
    /* [15] */
    /* fn abs[T : fi32_f16](T) -> T */
    /* fn abs[T : fi32_f16, N : num](vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(59),
  },
  {
    /* [16] */
    /* fn any[N : num](vec<N, bool>) -> bool */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(71),
  },
  {
    /* [17] */
    /* fn all[N : num](vec<N, bool>) -> bool */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(71),
  },
  {
    /* [18] */
    /* fn dot[T : f32_f16, N : num](vec<N, T>, vec<N, T>) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(72),
  },
  {
    /* [19] */
    /* fn modf[T : f32_f16](value: T, result: ptr<function, T, read_write>) -> T */
    /* fn modf[N : num, T : f32_f16](value: vec<N, T>, result: ptr<function, vec<N, T>, read_write>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(61),
  },
  {
    /* [20] */
    /* fn frexp[T : f32_f16](value: T, exp: ptr<function, i32, read_write>) -> T */
    /* fn frexp[N : num, T : f32_f16](value: vec<N, T>, exp: ptr<function, vec<N, i32>, read_write>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(63),
  },
  {
    /* [21] */
    /* fn textureSize[T : fiu32](texture: texture_1d<T>, level: i32) -> i32 */
    /* fn textureSize[T : fiu32](texture: texture_2d<T>, level: i32) -> vec2<i32> */
    /* fn textureSize[T : fiu32](texture: texture_2d_array<T>, level: i32) -> vec3<i32> */
    /* fn textureSize[T : fiu32](texture: texture_3d<T>, level: i32) -> vec3<i32> */
    /* fn textureSize[T : fiu32](texture: texture_cube<T>, level: i32) -> vec2<i32> */
    /* fn textureSize[T : fiu32](texture: texture_cube_array<T>, level: i32) -> vec3<i32> */
    /* fn textureSize(texture: texture_depth_2d, level: i32) -> vec2<i32> */
    /* fn textureSize(texture: texture_depth_2d_array, level: i32) -> vec3<i32> */
    /* fn textureSize(texture: texture_depth_cube, level: i32) -> vec2<i32> */
    /* fn textureSize(texture: texture_depth_cube_array, level: i32) -> vec3<i32> */
    /* fn textureSize[T : fiu32](texture: texture_multisampled_2d<T>) -> vec2<i32> */
    /* fn textureSize(texture: texture_depth_multisampled_2d) -> vec2<i32> */
    /* num overloads */ 12,
    /* overloads */ OverloadIndex(0),
  },
  {
    /* [22] */
    /* fn imageSize[F : texel_format, A : access](texture: texture_storage_1d<F, A>) -> i32 */
    /* fn imageSize[F : texel_format, A : access](texture: texture_storage_2d<F, A>) -> vec2<i32> */
    /* fn imageSize[F : texel_format, A : access](texture: texture_storage_2d_array<F, A>) -> vec3<i32> */
    /* fn imageSize[F : texel_format, A : access](texture: texture_storage_3d<F, A>) -> vec3<i32> */
    /* num overloads */ 4,
    /* overloads */ OverloadIndex(41),
  },
  {
    /* [23] */
    /* fn texelFetch[T : fiu32](texture: texture_1d<T>, location: i32, level: i32) -> vec4<T> */
    /* fn texelFetch[T : fiu32](texture: texture_2d<T>, location: vec2<i32>, level: i32) -> vec4<T> */
    /* fn texelFetch[T : fiu32](texture: texture_2d_array<T>, location: vec3<i32>, level: i32) -> vec4<T> */
    /* fn texelFetch[T : fiu32](texture: texture_multisampled_2d<T>, location: vec2<i32>, sample_index: i32) -> vec4<T> */
    /* fn texelFetch[T : fiu32](texture: texture_3d<T>, location: vec3<i32>, level: i32) -> vec4<T> */
    /* num overloads */ 5,
    /* overloads */ OverloadIndex(36),
  },
  {
    /* [24] */
    /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_1d<F, A>, coords: i32) -> vec4<f32> */
    /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_2d<F, A>, coords: vec2<i32>) -> vec4<f32> */
    /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_2d_array<F, A>, coords: vec3<i32>) -> vec4<f32> */
    /* fn imageLoad[F : f32_texel_format, A : readable](texture: texture_storage_3d<F, A>, coords: vec3<i32>) -> vec4<f32> */
    /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_1d<F, A>, coords: i32) -> vec4<i32> */
    /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_2d<F, A>, coords: vec2<i32>) -> vec4<i32> */
    /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_2d_array<F, A>, coords: vec3<i32>) -> vec4<i32> */
    /* fn imageLoad[F : i32_texel_format, A : readable](texture: texture_storage_3d<F, A>, coords: vec3<i32>) -> vec4<i32> */
    /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_1d<F, A>, coords: i32) -> vec4<u32> */
    /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_2d<F, A>, coords: vec2<i32>) -> vec4<u32> */
    /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_2d_array<F, A>, coords: vec3<i32>) -> vec4<u32> */
    /* fn imageLoad[F : u32_texel_format, A : readable](texture: texture_storage_3d<F, A>, coords: vec3<i32>) -> vec4<u32> */
    /* num overloads */ 12,
    /* overloads */ OverloadIndex(12),
  },
  {
    /* [25] */
    /* fn imageStore[C : iu32](texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>) */
    /* fn imageStore[C : iu32](texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>) */
    /* num overloads */ 12,
    /* overloads */ OverloadIndex(24),
  },
  {
    /* [26] */
    /* fn lessThan[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(73),
  },
  {
    /* [27] */
    /* fn lessThanEqual[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(73),
  },
  {
    /* [28] */
    /* fn greaterThan[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(73),
  },
  {
    /* [29] */
    /* fn greaterThanEqual[T : fiu32_f16, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(73),
  },
  {
    /* [30] */
    /* fn equal[T : fiu32_f16_bool, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(74),
  },
  {
    /* [31] */
    /* fn notEqual[T : fiu32_f16_bool, N : num](vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(74),
  },
};

// clang-format on

}  // anonymous namespace

const core::intrinsic::TableData Dialect::kData{
    /* templates */ kTemplates,
    /* type_matcher_indices */ kMatcherIndices,
    /* type_matchers */ kTypeMatchers,
    /* number_matchers */ kNumberMatchers,
    /* parameters */ kParameters,
    /* overloads */ kOverloads,
    /* const_eval_functions */ kConstEvalFunctions,
    /* ctor_conv */ Empty,
    /* builtins */ kBuiltins,
    /* binary '+' */ tint::core::intrinsic::kNoOverloads,
    /* binary '-' */ tint::core::intrinsic::kNoOverloads,
    /* binary '*' */ tint::core::intrinsic::kNoOverloads,
    /* binary '/' */ tint::core::intrinsic::kNoOverloads,
    /* binary '%' */ tint::core::intrinsic::kNoOverloads,
    /* binary '^' */ tint::core::intrinsic::kNoOverloads,
    /* binary '&' */ tint::core::intrinsic::kNoOverloads,
    /* binary '|' */ tint::core::intrinsic::kNoOverloads,
    /* binary '&&' */ tint::core::intrinsic::kNoOverloads,
    /* binary '||' */ tint::core::intrinsic::kNoOverloads,
    /* binary '==' */ tint::core::intrinsic::kNoOverloads,
    /* binary '!=' */ tint::core::intrinsic::kNoOverloads,
    /* binary '<' */ tint::core::intrinsic::kNoOverloads,
    /* binary '>' */ tint::core::intrinsic::kNoOverloads,
    /* binary '<=' */ tint::core::intrinsic::kNoOverloads,
    /* binary '>=' */ tint::core::intrinsic::kNoOverloads,
    /* binary '<<' */ tint::core::intrinsic::kNoOverloads,
    /* binary '>>' */ tint::core::intrinsic::kNoOverloads,
    /* unary '!' */ tint::core::intrinsic::kNoOverloads,
    /* unary '~' */ tint::core::intrinsic::kNoOverloads,
    /* unary '-' */ tint::core::intrinsic::kNoOverloads,
    /* unary '*' */ tint::core::intrinsic::kNoOverloads,
    /* unary '&' */ tint::core::intrinsic::kNoOverloads,
};

}  // namespace tint::glsl::intrinsic