src/tint/lang/spirv/intrinsic/data/data.cc

// Copyright 2023 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

////////////////////////////////////////////////////////////////////////////////
// File generated by 'tools/src/cmd/gen' using the template:
//   src/tint/lang/spirv/intrinsic/data/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/data/type_matchers.h"
#include "src/tint/lang/spirv/intrinsic/data/data.h"
#include "src/tint/lang/spirv/intrinsic/data/type_matchers.h"
#include "src/tint/utils/text/string_stream.h"

namespace tint::spirv::intrinsic::data {

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

namespace {

using ConstEvalFunctionIndex = tint::core::intrinsic::ConstEvalFunctionIndex;
using IntrinsicInfo = tint::core::intrinsic::IntrinsicInfo;
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 NumberMatcherIndicesIndex = tint::core::intrinsic::NumberMatcherIndicesIndex;
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 TemplateNumberIndex = tint::core::intrinsic::TemplateNumberIndex;
using TemplateNumberInfo = tint::core::intrinsic::TemplateNumberInfo;
using TemplateTypeIndex = tint::core::intrinsic::TemplateTypeIndex;
using TemplateTypeInfo = tint::core::intrinsic::TemplateTypeInfo;
using Type = tint::core::type::Type;
using TypeMatcher = tint::core::intrinsic::TypeMatcher;
using TypeMatcherIndex = tint::core::intrinsic::TypeMatcherIndex;
using TypeMatcherIndicesIndex = tint::core::intrinsic::TypeMatcherIndicesIndex;

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);
  },
/* string */ [](MatchState*) -> std::string {
    return "bool";
  }
};


/// 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);
  },
/* string */ [](MatchState*) -> std::string {
    return "f32";
  }
};


/// 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);
  },
/* string */ [](MatchState*) -> std::string {
    return "f16";
  }
};


/// 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);
  },
/* string */ [](MatchState*) -> std::string {
    return "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);
  },
/* string */ [](MatchState*) -> std::string {
    return "u32";
  }
};


/// 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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "vec4<" + T + ">";
  }
};


/// TypeMatcher for 'type mat2x2'
constexpr TypeMatcher kMat2X2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat2X2(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat2X2(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat2x2<" + T + ">";
  }
};


/// TypeMatcher for 'type mat2x3'
constexpr TypeMatcher kMat2X3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat2X3(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat2X3(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat2x3<" + T + ">";
  }
};


/// TypeMatcher for 'type mat2x4'
constexpr TypeMatcher kMat2X4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat2X4(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat2X4(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat2x4<" + T + ">";
  }
};


/// TypeMatcher for 'type mat3x2'
constexpr TypeMatcher kMat3X2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat3X2(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat3X2(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat3x2<" + T + ">";
  }
};


/// TypeMatcher for 'type mat3x3'
constexpr TypeMatcher kMat3X3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat3X3(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat3X3(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat3x3<" + T + ">";
  }
};


/// TypeMatcher for 'type mat3x4'
constexpr TypeMatcher kMat3X4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat3X4(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat3X4(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat3x4<" + T + ">";
  }
};


/// TypeMatcher for 'type mat4x2'
constexpr TypeMatcher kMat4X2Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat4X2(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat4X2(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat4x2<" + T + ">";
  }
};


/// TypeMatcher for 'type mat4x3'
constexpr TypeMatcher kMat4X3Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat4X3(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat4X3(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat4x3<" + T + ">";
  }
};


/// TypeMatcher for 'type mat4x4'
constexpr TypeMatcher kMat4X4Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchMat4X4(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat4X4(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "mat4x4<" + 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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string N = state->NumName();
  const std::string T = state->TypeName();
    StringStream ss;
    ss << "vec" << N << "<" << T << ">";
    return ss.str();
  }
};


/// TypeMatcher for 'type mat'
constexpr TypeMatcher kMatMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number N = Number::invalid;
  Number M = Number::invalid;
  const Type* T = nullptr;
    if (!MatchMat(state, ty, N, M, T)) {
      return nullptr;
    }
    N = state.Num(N);
    if (!N.IsValid()) {
      return nullptr;
    }
    M = state.Num(M);
    if (!M.IsValid()) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildMat(state, ty, N, M, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string N = state->NumName();
  const std::string M = state->NumName();
  const std::string T = state->TypeName();
    StringStream ss;
    ss << "mat" << N << "x" << M << "<" << T << ">";
    return ss.str();
  }
};


/// 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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "atomic<" + T + ">";
  }
};


/// TypeMatcher for 'type sampler'
constexpr TypeMatcher kSamplerMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchSampler(state, ty)) {
      return nullptr;
    }
    return BuildSampler(state, ty);
  },
/* string */ [](MatchState*) -> std::string {
    return "sampler";
  }
};


/// TypeMatcher for 'type sampler_comparison'
constexpr TypeMatcher kSamplerComparisonMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchSamplerComparison(state, ty)) {
      return nullptr;
    }
    return BuildSamplerComparison(state, ty);
  },
/* string */ [](MatchState*) -> std::string {
    return "sampler_comparison";
  }
};


/// 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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "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);
  },
/* string */ [](MatchState*) -> std::string {
    return "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);
  },
/* string */ [](MatchState*) -> std::string {
    return "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);
  },
/* string */ [](MatchState*) -> std::string {
    return "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);
  },
/* string */ [](MatchState*) -> std::string {
    return "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);
  },
/* string */ [](MatchState*) -> std::string {
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string F = state->NumName();
  const std::string A = state->NumName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string F = state->NumName();
  const std::string A = state->NumName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string F = state->NumName();
  const std::string A = state->NumName();
    return "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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string F = state->NumName();
  const std::string A = state->NumName();
    return "texture_storage_3d<" + F + ", " + A + ">";
  }
};


/// 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);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string S = state->NumName();
  const std::string T = state->TypeName();
  const std::string A = state->NumName();
    return "ptr<" + S + ", " + T + ", " + A + ">";
  }
};


/// TypeMatcher for 'type struct_with_runtime_array'
constexpr TypeMatcher kStructWithRuntimeArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchStructWithRuntimeArray(state, ty)) {
      return nullptr;
    }
    return BuildStructWithRuntimeArray(state, ty);
  },
/* string */ [](MatchState*) -> std::string {
    return "struct_with_runtime_array";
  }
};


/// TypeMatcher for 'type sampled_image'
constexpr TypeMatcher kSampledImageMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchSampledImage(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildSampledImage(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "sampled_image<" + T + ">";
  }
};


/// 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;
  },
/* string */ [](MatchState*) -> std::string {
    StringStream ss;
    // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
    ss << kF32Matcher.string(nullptr) << " or " << kF16Matcher.string(nullptr);
    return ss.str();
  }
};

/// 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;
  },
/* string */ [](MatchState*) -> std::string {
    StringStream ss;
    // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
    ss << kI32Matcher.string(nullptr) << " or " << kU32Matcher.string(nullptr);
    return ss.str();
  }
};

/// 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;
  },
/* string */ [](MatchState*) -> std::string {
    StringStream ss;
    // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
    ss << kF32Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << " or " << kU32Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match scalar'
constexpr TypeMatcher kScalarMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchBool(state, ty)) {
      return BuildBool(state, ty);
    }
    return nullptr;
  },
/* string */ [](MatchState*) -> std::string {
    StringStream ss;
    // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
    ss << kF32Matcher.string(nullptr) << ", " << kF16Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << ", " << kU32Matcher.string(nullptr) << " or " << kBoolMatcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match samplers'
constexpr TypeMatcher kSamplersMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchSampler(state, ty)) {
      return BuildSampler(state, ty);
    }
    if (MatchSamplerComparison(state, ty)) {
      return BuildSamplerComparison(state, ty);
    }
    return nullptr;
  },
/* string */ [](MatchState*) -> std::string {
    StringStream ss;
    // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
    // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
    ss << kSamplerMatcher.string(nullptr) << " or " << kSamplerComparisonMatcher.string(nullptr);
    return ss.str();
  }
};

/// 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;
  },
/* string */ [](MatchState*) -> std::string {
    return "read_write";
  }
};

/// 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;
  },
/* string */ [](MatchState*) -> std::string {
    return "storage";
  }
};

/// EnumMatcher for 'match workgroup_or_storage'
constexpr NumberMatcher kWorkgroupOrStorageMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::AddressSpace>(number.Value())) {
      case core::AddressSpace::kWorkgroup:
      case core::AddressSpace::kStorage:
        return number;
      default:
        return Number::invalid;
    }
  },
/* string */ [](MatchState*) -> std::string {
    return "workgroup or 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::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;
    }
  },
/* string */ [](MatchState*) -> std::string {
    return "bgra8unorm, rgba8unorm, rgba8snorm, rgba16float, r32float, rg32float or rgba32float";
  }
};

/// 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;
    }
  },
/* string */ [](MatchState*) -> std::string {
    return "rgba8sint, rgba16sint, r32sint, rg32sint or rgba32sint";
  }
};

/// 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;
    }
  },
/* string */ [](MatchState*) -> std::string {
    return "rgba8uint, rgba16uint, r32uint, rg32uint or rgba32uint";
  }
};

/// 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;
    }
  },
/* string */ [](MatchState*) -> std::string {
    return "read or read_write";
  }
};

/// Type and number matchers

/// The template types, types, and type matchers
constexpr TypeMatcher kTypeMatchers[] = {
  /* [0] */ TemplateTypeMatcher<0>::matcher,
  /* [1] */ TemplateTypeMatcher<1>::matcher,
  /* [2] */ TemplateTypeMatcher<2>::matcher,
  /* [3] */ TemplateTypeMatcher<3>::matcher,
  /* [4] */ kBoolMatcher,
  /* [5] */ kF32Matcher,
  /* [6] */ kF16Matcher,
  /* [7] */ kI32Matcher,
  /* [8] */ kU32Matcher,
  /* [9] */ kVec2Matcher,
  /* [10] */ kVec3Matcher,
  /* [11] */ kVec4Matcher,
  /* [12] */ kMat2X2Matcher,
  /* [13] */ kMat2X3Matcher,
  /* [14] */ kMat2X4Matcher,
  /* [15] */ kMat3X2Matcher,
  /* [16] */ kMat3X3Matcher,
  /* [17] */ kMat3X4Matcher,
  /* [18] */ kMat4X2Matcher,
  /* [19] */ kMat4X3Matcher,
  /* [20] */ kMat4X4Matcher,
  /* [21] */ kVecMatcher,
  /* [22] */ kMatMatcher,
  /* [23] */ kAtomicMatcher,
  /* [24] */ kSamplerMatcher,
  /* [25] */ kSamplerComparisonMatcher,
  /* [26] */ kTexture1DMatcher,
  /* [27] */ kTexture2DMatcher,
  /* [28] */ kTexture2DArrayMatcher,
  /* [29] */ kTexture3DMatcher,
  /* [30] */ kTextureCubeMatcher,
  /* [31] */ kTextureCubeArrayMatcher,
  /* [32] */ kTextureMultisampled2DMatcher,
  /* [33] */ kTextureDepth2DMatcher,
  /* [34] */ kTextureDepth2DArrayMatcher,
  /* [35] */ kTextureDepthCubeMatcher,
  /* [36] */ kTextureDepthCubeArrayMatcher,
  /* [37] */ kTextureDepthMultisampled2DMatcher,
  /* [38] */ kTextureStorage1DMatcher,
  /* [39] */ kTextureStorage2DMatcher,
  /* [40] */ kTextureStorage2DArrayMatcher,
  /* [41] */ kTextureStorage3DMatcher,
  /* [42] */ kPtrMatcher,
  /* [43] */ kStructWithRuntimeArrayMatcher,
  /* [44] */ kSampledImageMatcher,
  /* [45] */ kF32F16Matcher,
  /* [46] */ kIu32Matcher,
  /* [47] */ kFiu32Matcher,
  /* [48] */ kScalarMatcher,
  /* [49] */ kSamplersMatcher,
};

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

constexpr TypeMatcherIndex kTypeMatcherIndices[] = {
  /* [0] */ TypeMatcherIndex(42),
  /* [1] */ TypeMatcherIndex(23),
  /* [2] */ TypeMatcherIndex(0),
  /* [3] */ TypeMatcherIndex(44),
  /* [4] */ TypeMatcherIndex(26),
  /* [5] */ TypeMatcherIndex(0),
  /* [6] */ TypeMatcherIndex(44),
  /* [7] */ TypeMatcherIndex(27),
  /* [8] */ TypeMatcherIndex(0),
  /* [9] */ TypeMatcherIndex(44),
  /* [10] */ TypeMatcherIndex(28),
  /* [11] */ TypeMatcherIndex(0),
  /* [12] */ TypeMatcherIndex(44),
  /* [13] */ TypeMatcherIndex(29),
  /* [14] */ TypeMatcherIndex(0),
  /* [15] */ TypeMatcherIndex(44),
  /* [16] */ TypeMatcherIndex(30),
  /* [17] */ TypeMatcherIndex(0),
  /* [18] */ TypeMatcherIndex(44),
  /* [19] */ TypeMatcherIndex(31),
  /* [20] */ TypeMatcherIndex(0),
  /* [21] */ TypeMatcherIndex(42),
  /* [22] */ TypeMatcherIndex(43),
  /* [23] */ TypeMatcherIndex(21),
  /* [24] */ TypeMatcherIndex(0),
  /* [25] */ TypeMatcherIndex(11),
  /* [26] */ TypeMatcherIndex(5),
  /* [27] */ TypeMatcherIndex(44),
  /* [28] */ TypeMatcherIndex(33),
  /* [29] */ TypeMatcherIndex(9),
  /* [30] */ TypeMatcherIndex(5),
  /* [31] */ TypeMatcherIndex(9),
  /* [32] */ TypeMatcherIndex(2),
  /* [33] */ TypeMatcherIndex(44),
  /* [34] */ TypeMatcherIndex(34),
  /* [35] */ TypeMatcherIndex(10),
  /* [36] */ TypeMatcherIndex(5),
  /* [37] */ TypeMatcherIndex(44),
  /* [38] */ TypeMatcherIndex(35),
  /* [39] */ TypeMatcherIndex(44),
  /* [40] */ TypeMatcherIndex(36),
  /* [41] */ TypeMatcherIndex(11),
  /* [42] */ TypeMatcherIndex(0),
  /* [43] */ TypeMatcherIndex(9),
  /* [44] */ TypeMatcherIndex(1),
  /* [45] */ TypeMatcherIndex(10),
  /* [46] */ TypeMatcherIndex(1),
  /* [47] */ TypeMatcherIndex(32),
  /* [48] */ TypeMatcherIndex(0),
  /* [49] */ TypeMatcherIndex(9),
  /* [50] */ TypeMatcherIndex(7),
  /* [51] */ TypeMatcherIndex(9),
  /* [52] */ TypeMatcherIndex(3),
  /* [53] */ TypeMatcherIndex(9),
  /* [54] */ TypeMatcherIndex(8),
  /* [55] */ TypeMatcherIndex(10),
  /* [56] */ TypeMatcherIndex(8),
  /* [57] */ TypeMatcherIndex(11),
  /* [58] */ TypeMatcherIndex(7),
  /* [59] */ TypeMatcherIndex(11),
  /* [60] */ TypeMatcherIndex(8),
  /* [61] */ TypeMatcherIndex(9),
  /* [62] */ TypeMatcherIndex(0),
  /* [63] */ TypeMatcherIndex(10),
  /* [64] */ TypeMatcherIndex(0),
  /* [65] */ TypeMatcherIndex(22),
  /* [66] */ TypeMatcherIndex(0),
  /* [67] */ TypeMatcherIndex(21),
  /* [68] */ TypeMatcherIndex(4),
  /* [69] */ TypeMatcherIndex(37),
  /* [70] */ TypeMatcherIndex(38),
  /* [71] */ TypeMatcherIndex(39),
  /* [72] */ TypeMatcherIndex(40),
  /* [73] */ TypeMatcherIndex(41),
};

static_assert(TypeMatcherIndex::CanIndex(kTypeMatcherIndices),
              "TypeMatcherIndex is not large enough to index kTypeMatcherIndices");

constexpr NumberMatcherIndex kNumberMatcherIndices[] = {
  /* [0] */ NumberMatcherIndex(4),
  /* [1] */ NumberMatcherIndex(0),
  /* [2] */ NumberMatcherIndex(3),
  /* [3] */ NumberMatcherIndex(0),
  /* [4] */ NumberMatcherIndex(1),
  /* [5] */ NumberMatcherIndex(2),
  /* [6] */ NumberMatcherIndex(0),
  /* [7] */ NumberMatcherIndex(2),
  /* [8] */ NumberMatcherIndex(1),
  /* [9] */ NumberMatcherIndex(0),
};

static_assert(NumberMatcherIndex::CanIndex(kNumberMatcherIndices),
              "NumberMatcherIndex is not large enough to index kNumberMatcherIndices");

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

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

constexpr TemplateTypeInfo kTemplateTypes[] = {
  {
    /* [0] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(47),
  },
  {
    /* [1] */
    /* name */ "C",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [2] */
    /* name */ "I",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [3] */
    /* name */ "S",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [4] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(47),
  },
  {
    /* [5] */
    /* name */ "A",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [6] */
    /* name */ "B",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [7] */
    /* name */ "C",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [8] */
    /* name */ "S",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [9] */
    /* name */ "A",
    /* matcher_index */ TypeMatcherIndex(5),
  },
  {
    /* [10] */
    /* name */ "B",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [11] */
    /* name */ "C",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [12] */
    /* name */ "I",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [13] */
    /* name */ "C",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [14] */
    /* name */ "S",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [15] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(46),
  },
  {
    /* [16] */
    /* name */ "U",
    /* matcher_index */ TypeMatcherIndex(8),
  },
  {
    /* [17] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(47),
  },
  {
    /* [18] */
    /* name */ "S",
    /* matcher_index */ TypeMatcherIndex(49),
  },
  {
    /* [19] */
    /* name */ "I",
    /* matcher_index */ TypeMatcherIndex(8),
  },
  {
    /* [20] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(45),
  },
  {
    /* [21] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(48),
  },
};

static_assert(TemplateTypeIndex::CanIndex(kTemplateTypes),
              "TemplateTypeIndex is not large enough to index kTemplateTypes");

constexpr TemplateNumberInfo kTemplateNumbers[] = {
  {
    /* [0] */
    /* name */ "K",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [1] */
    /* name */ "C",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [2] */
    /* name */ "R",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [3] */
    /* name */ "F",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [4] */
    /* name */ "A",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [5] */
    /* name */ "F",
    /* matcher_index */ NumberMatcherIndex(6),
  },
  {
    /* [6] */
    /* name */ "A",
    /* matcher_index */ NumberMatcherIndex(9),
  },
  {
    /* [7] */
    /* name */ "F",
    /* matcher_index */ NumberMatcherIndex(7),
  },
  {
    /* [8] */
    /* name */ "A",
    /* matcher_index */ NumberMatcherIndex(9),
  },
  {
    /* [9] */
    /* name */ "F",
    /* matcher_index */ NumberMatcherIndex(8),
  },
  {
    /* [10] */
    /* name */ "A",
    /* matcher_index */ NumberMatcherIndex(9),
  },
  {
    /* [11] */
    /* name */ "N",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [12] */
    /* name */ "M",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [13] */
    /* name */ "S",
    /* matcher_index */ NumberMatcherIndex(5),
  },
};

static_assert(TemplateNumberIndex::CanIndex(kTemplateNumbers),
              "TemplateNumberIndex is not large enough to index kTemplateNumbers");

constexpr OverloadInfo kOverloads[] = {
  {
    /* [0] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(38),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [1] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(42),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [2] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(46),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [3] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(50),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [4] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(113),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [5] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(115),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [6] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(54),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [7] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(58),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [8] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(62),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [9] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(121),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [10] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(123),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [11] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(66),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [12] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(3),
    /* parameters */ ParameterIndex(86),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [13] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(3),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [14] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(3),
    /* parameters */ ParameterIndex(92),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [15] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(3),
    /* parameters */ ParameterIndex(95),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [16] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(70),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [17] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(16),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [18] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 5,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(16),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [19] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(21),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [20] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 5,
    /* num_template_types */ 4,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(21),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [21] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(74),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [22] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(78),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [23] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(82),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [24] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(6),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [25] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 5,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(6),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [26] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(11),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [27] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 5,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(11),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [28] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(30),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [29] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(34),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [30] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(5),
    /* parameters */ ParameterIndex(86),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [31] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(7),
    /* parameters */ ParameterIndex(86),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(57),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [32] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(9),
    /* parameters */ ParameterIndex(86),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(59),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [33] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(5),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [34] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(7),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(57),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [35] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(9),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(59),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [36] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(5),
    /* parameters */ ParameterIndex(92),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [37] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(7),
    /* parameters */ ParameterIndex(92),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(57),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [38] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(9),
    /* parameters */ ParameterIndex(92),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(59),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [39] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(5),
    /* parameters */ ParameterIndex(95),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [40] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(7),
    /* parameters */ ParameterIndex(95),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(57),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [41] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(9),
    /* parameters */ ParameterIndex(95),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(59),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [42] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(38),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [43] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(107),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [44] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(109),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [45] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(111),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [46] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(113),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [47] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(115),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [48] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(117),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [49] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(119),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [50] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(121),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [51] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(123),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(55),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [52] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(17),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(38),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(3),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [53] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(17),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(107),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [54] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(17),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(109),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [55] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(17),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(111),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [56] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(17),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(113),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [57] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(17),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(115),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(18),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [58] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(18),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(117),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(27),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [59] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(18),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(119),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(33),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [60] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(18),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(121),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(37),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [61] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(18),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(123),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(39),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [62] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 4,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(38),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [63] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 4,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(42),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [64] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 4,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(46),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [65] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 4,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(50),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [66] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 4,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(54),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(41),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [67] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(58),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [68] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(62),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [69] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(66),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [70] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(9),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(6),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [71] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 5,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(9),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(6),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [72] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(9),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(11),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [73] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 5,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(9),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(11),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [74] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(9),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(30),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [75] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(9),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(34),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(25),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [76] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(21),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(98),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [77] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(21),
    /* template_numbers */ TemplateNumberIndex(11),
    /* parameters */ ParameterIndex(101),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(23),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [78] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(19),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(105),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [79] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(15),
    /* template_numbers */ TemplateNumberIndex(13),
    /* parameters */ ParameterIndex(26),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [80] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 6,
    /* num_template_types */ 2,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(15),
    /* template_numbers */ TemplateNumberIndex(13),
    /* parameters */ ParameterIndex(0),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [81] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(15),
    /* template_numbers */ TemplateNumberIndex(13),
    /* parameters */ ParameterIndex(0),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [82] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(15),
    /* template_numbers */ TemplateNumberIndex(13),
    /* parameters */ ParameterIndex(26),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [83] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(11),
    /* parameters */ ParameterIndex(102),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [84] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 3,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(0),
    /* parameters */ ParameterIndex(125),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(65),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(4),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [85] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(11),
    /* parameters */ ParameterIndex(127),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(65),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [86] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(11),
    /* parameters */ ParameterIndex(129),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(23),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(4),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [87] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(11),
    /* parameters */ ParameterIndex(103),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(23),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(4),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [88] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(11),
    /* parameters */ ParameterIndex(130),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(23),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
};

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

constexpr IntrinsicInfo kBuiltins[] = {
  {
    /* [0] */
    /* fn array_length<I : u32, A : access>(ptr<storage, struct_with_runtime_array, A>, I) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(78),
  },
  {
    /* [1] */
    /* fn atomic_and<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [2] */
    /* fn atomic_compare_exchange<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, U, T, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(80),
  },
  {
    /* [3] */
    /* fn atomic_exchange<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [4] */
    /* fn atomic_iadd<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [5] */
    /* fn atomic_isub<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [6] */
    /* fn atomic_load<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(81),
  },
  {
    /* [7] */
    /* fn atomic_or<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [8] */
    /* fn atomic_smax<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [9] */
    /* fn atomic_smin<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [10] */
    /* fn atomic_store<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(82),
  },
  {
    /* [11] */
    /* fn atomic_umax<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [12] */
    /* fn atomic_umin<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [13] */
    /* fn atomic_xor<T : iu32, U : u32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, U, U, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [14] */
    /* fn dot<N : num, T : f32_f16>(vec<N, T>, vec<N, T>) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(83),
  },
  {
    /* [15] */
    /* fn image_dref_gather<A : f32, B : iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B) -> vec4<f32> */
    /* fn image_dref_gather<A : f32, B : iu32, C : iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B, vec2<C>) -> vec4<f32> */
    /* fn image_dref_gather<A : f32, B : iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B) -> vec4<f32> */
    /* fn image_dref_gather<A : f32, B : iu32, C : iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B, vec2<C>) -> vec4<f32> */
    /* fn image_dref_gather<A : f32, B : iu32>(sampled_image<texture_depth_cube>, vec3<f32>, A, B) -> vec4<f32> */
    /* fn image_dref_gather<A : f32, B : iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, A, B) -> vec4<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(70),
  },
  {
    /* [16] */
    /* fn image_fetch<T : fiu32, C : iu32, I : iu32, S : iu32>(texture_1d<T>, C, I, S) -> vec4<T> */
    /* fn image_fetch<T : fiu32, C : iu32, I : iu32, S : iu32>(texture_2d<T>, vec2<C>, I, S) -> vec4<T> */
    /* fn image_fetch<T : fiu32, C : iu32, I : iu32, S : iu32>(texture_2d_array<T>, vec3<C>, I, S) -> vec4<T> */
    /* fn image_fetch<T : fiu32, C : iu32, I : iu32, S : iu32>(texture_3d<T>, vec3<C>, I, S) -> vec4<T> */
    /* fn image_fetch<T : fiu32, C : iu32, I : iu32, S : iu32>(texture_multisampled_2d<T>, vec2<C>, I, S) -> vec4<T> */
    /* fn image_fetch<I : iu32, C : iu32, S : iu32>(texture_depth_2d, vec2<C>, I, S) -> vec4<f32> */
    /* fn image_fetch<I : iu32, C : iu32, S : iu32>(texture_depth_2d_array, vec3<C>, I, S) -> vec4<f32> */
    /* fn image_fetch<I : iu32, C : iu32, S : iu32>(texture_depth_multisampled_2d, vec2<C>, I, S) -> vec4<f32> */
    /* num overloads */ 8,
    /* overloads */ OverloadIndex(62),
  },
  {
    /* [17] */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32>(sampled_image<texture_1d<T>>, vec2<f32>, A, B) -> vec4<T> */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32>(sampled_image<texture_2d<T>>, vec2<f32>, A, B) -> vec4<T> */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32>(sampled_image<texture_2d<T>>, vec2<f32>, A, B, vec2<i32>) -> vec4<T> */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32>(sampled_image<texture_2d_array<T>>, vec3<f32>, A, B) -> vec4<T> */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32, C : iu32>(sampled_image<texture_2d_array<T>>, vec3<f32>, A, B, vec2<C>) -> vec4<T> */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32>(sampled_image<texture_3d<T>>, vec2<f32>, A, B) -> vec4<T> */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32>(sampled_image<texture_cube<T>>, vec3<f32>, A, B) -> vec4<T> */
    /* fn image_gather<T : fiu32, A : iu32, B : iu32>(sampled_image<texture_cube_array<T>>, vec4<f32>, A, B) -> vec4<T> */
    /* fn image_gather<A : iu32, B : iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B) -> vec4<f32> */
    /* fn image_gather<A : iu32, B : iu32, C : iu32>(sampled_image<texture_depth_2d>, vec2<f32>, A, B, vec2<C>) -> vec4<f32> */
    /* fn image_gather<A : iu32, B : iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B) -> vec4<f32> */
    /* fn image_gather<A : iu32, B : iu32, C : iu32>(sampled_image<texture_depth_2d_array>, vec3<f32>, A, B, vec2<C>) -> vec4<f32> */
    /* fn image_gather<A : iu32, B : iu32>(sampled_image<texture_depth_cube>, vec3<f32>, A, B) -> vec4<f32> */
    /* fn image_gather<A : iu32, B : iu32>(sampled_image<texture_depth_cube_array>, vec4<f32>, A, B) -> vec4<f32> */
    /* num overloads */ 14,
    /* overloads */ OverloadIndex(16),
  },
  {
    /* [18] */
    /* fn image_query_size<T : fiu32>(texture_1d<T>) -> u32 */
    /* fn image_query_size<T : fiu32>(texture_2d<T>) -> vec2<u32> */
    /* fn image_query_size<T : fiu32>(texture_2d_array<T>) -> vec3<u32> */
    /* fn image_query_size<T : fiu32>(texture_3d<T>) -> vec3<u32> */
    /* fn image_query_size<T : fiu32>(texture_cube<T>) -> vec2<u32> */
    /* fn image_query_size<T : fiu32>(texture_cube_array<T>) -> vec3<u32> */
    /* fn image_query_size<T : fiu32>(texture_multisampled_2d<T>) -> vec2<u32> */
    /* fn image_query_size(texture_depth_2d) -> vec2<u32> */
    /* fn image_query_size(texture_depth_2d_array) -> vec3<u32> */
    /* fn image_query_size(texture_depth_cube) -> vec2<u32> */
    /* fn image_query_size(texture_depth_cube_array) -> vec3<u32> */
    /* fn image_query_size(texture_depth_multisampled_2d) -> vec2<u32> */
    /* fn image_query_size<F : texel_format, A : access>(texture_storage_1d<F, A>) -> u32 */
    /* fn image_query_size<F : texel_format, A : access>(texture_storage_2d<F, A>) -> vec2<u32> */
    /* fn image_query_size<F : texel_format, A : access>(texture_storage_2d_array<F, A>) -> vec3<u32> */
    /* fn image_query_size<F : texel_format, A : access>(texture_storage_3d<F, A>) -> vec3<u32> */
    /* num overloads */ 16,
    /* overloads */ OverloadIndex(0),
  },
  {
    /* [19] */
    /* fn image_query_size_lod<T : fiu32, A : iu32>(texture_1d<T>, A) -> u32 */
    /* fn image_query_size_lod<T : fiu32, A : iu32>(texture_2d<T>, A) -> vec2<u32> */
    /* fn image_query_size_lod<T : fiu32, A : iu32>(texture_2d_array<T>, A) -> vec3<u32> */
    /* fn image_query_size_lod<T : fiu32, A : iu32>(texture_3d<T>, A) -> vec3<u32> */
    /* fn image_query_size_lod<T : fiu32, A : iu32>(texture_cube<T>, A) -> vec2<u32> */
    /* fn image_query_size_lod<T : fiu32, A : iu32>(texture_cube_array<T>, A) -> vec3<u32> */
    /* fn image_query_size_lod<A : iu32>(texture_depth_2d, A) -> vec2<u32> */
    /* fn image_query_size_lod<A : iu32>(texture_depth_2d_array, A) -> vec3<u32> */
    /* fn image_query_size_lod<A : iu32>(texture_depth_cube, A) -> vec2<u32> */
    /* fn image_query_size_lod<A : iu32>(texture_depth_cube_array, A) -> vec3<u32> */
    /* num overloads */ 10,
    /* overloads */ OverloadIndex(42),
  },
  {
    /* [20] */
    /* fn image_read<F : f32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_1d<F, A>, C, S) -> vec4<f32> */
    /* fn image_read<F : i32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_1d<F, A>, C, S) -> vec4<i32> */
    /* fn image_read<F : u32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_1d<F, A>, C, S) -> vec4<u32> */
    /* fn image_read<F : f32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_2d<F, A>, vec2<C>, S) -> vec4<f32> */
    /* fn image_read<F : i32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_2d<F, A>, vec2<C>, S) -> vec4<i32> */
    /* fn image_read<F : u32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_2d<F, A>, vec2<C>, S) -> vec4<u32> */
    /* fn image_read<F : f32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<f32> */
    /* fn image_read<F : i32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<i32> */
    /* fn image_read<F : u32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_2d_array<F, A>, vec3<C>, S) -> vec4<u32> */
    /* fn image_read<F : f32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_3d<F, A>, vec3<C>, S) -> vec4<f32> */
    /* fn image_read<F : i32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_3d<F, A>, vec3<C>, S) -> vec4<i32> */
    /* fn image_read<F : u32_texel_format, A : readable, C : iu32, S : iu32>(texture_storage_3d<F, A>, vec3<C>, S) -> vec4<u32> */
    /* num overloads */ 12,
    /* overloads */ OverloadIndex(30),
  },
  {
    /* [21] */
    /* fn matrix_times_matrix<T : f32_f16, K : num, C : num, R : num>(mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(84),
  },
  {
    /* [22] */
    /* fn matrix_times_scalar<T : f32_f16, N : num, M : num>(mat<N, M, T>, T) -> mat<N, M, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(85),
  },
  {
    /* [23] */
    /* fn matrix_times_vector<T : f32_f16, N : num, M : num>(mat<N, M, T>, vec<N, T>) -> vec<M, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(86),
  },
  {
    /* [24] */
    /* fn sampled_image<T : fiu32, S : samplers>(texture_1d<T>, S) -> sampled_image<texture_1d<T>> */
    /* fn sampled_image<T : fiu32, S : samplers>(texture_2d<T>, S) -> sampled_image<texture_2d<T>> */
    /* fn sampled_image<T : fiu32, S : samplers>(texture_2d_array<T>, S) -> sampled_image<texture_2d_array<T>> */
    /* fn sampled_image<T : fiu32, S : samplers>(texture_3d<T>, S) -> sampled_image<texture_3d<T>> */
    /* fn sampled_image<T : fiu32, S : samplers>(texture_cube<T>, S) -> sampled_image<texture_cube<T>> */
    /* fn sampled_image<T : fiu32, S : samplers>(texture_cube_array<T>, S) -> sampled_image<texture_cube_array<T>> */
    /* fn sampled_image<S : samplers>(texture_depth_2d, S) -> sampled_image<texture_depth_2d> */
    /* fn sampled_image<S : samplers>(texture_depth_2d_array, S) -> sampled_image<texture_depth_2d_array> */
    /* fn sampled_image<S : samplers>(texture_depth_cube, S) -> sampled_image<texture_depth_cube> */
    /* fn sampled_image<S : samplers>(texture_depth_cube_array, S) -> sampled_image<texture_depth_cube_array> */
    /* num overloads */ 10,
    /* overloads */ OverloadIndex(52),
  },
  {
    /* [25] */
    /* fn select<T : scalar>(bool, T, T) -> T */
    /* fn select<N : num, T : scalar>(vec<N, bool>, vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(76),
  },
  {
    /* [26] */
    /* fn vector_times_matrix<T : f32_f16, N : num, M : num>(vec<N, T>, mat<M, N, T>) -> vec<M, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(87),
  },
  {
    /* [27] */
    /* fn vector_times_scalar<T : f32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(88),
  },
};

// clang-format on

}  // anonymous namespace

const core::intrinsic::TableData kData{
    /* template_types */ kTemplateTypes,
    /* template_numbers */ kTemplateNumbers,
    /* type_matcher_indices */ kTypeMatcherIndices,
    /* number_matcher_indices */ kNumberMatcherIndices,
    /* type_matchers */ kTypeMatchers,
    /* number_matchers */ kNumberMatchers,
    /* parameters */ kParameters,
    /* overloads */ kOverloads,
    /* const_eval_functions */ Empty,
    /* 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,
};

}  // namespace tint::spirv::intrinsic::data