// 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/core/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/data.h"
#include "src/tint/lang/core/intrinsic/data/type_matchers.h"
#include "src/tint/utils/text/string_stream.h"

namespace tint::core::intrinsic::data {

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 ia'
constexpr TypeMatcher kIaMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchIa(state, ty)) {
      return nullptr;
    }
    return BuildIa(state, ty);
  },
/* string */ [](MatchState*) -> std::string {
    StringStream ss;
    ss << "abstract-int";
    return ss.str();
  }
};


/// TypeMatcher for 'type fa'
constexpr TypeMatcher kFaMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchFa(state, ty)) {
      return nullptr;
    }
    return BuildFa(state, ty);
  },
/* string */ [](MatchState*) -> std::string {
    StringStream ss;
    ss << "abstract-float";
    return ss.str();
  }
};


/// 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 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 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 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 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 array'
constexpr TypeMatcher kArrayMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchArray(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildArray(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    return "array<" + 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 texture_external'
constexpr TypeMatcher kTextureExternalMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (!MatchTextureExternal(state, ty)) {
      return nullptr;
    }
    return BuildTextureExternal(state, ty);
  },
/* string */ [](MatchState*) -> std::string {
    return "texture_external";
  }
};


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


/// TypeMatcher for 'type __modf_result'
constexpr TypeMatcher kModfResultMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchModfResult(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildModfResult(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    StringStream ss;
    ss << "__modf_result_" << T;
    return ss.str();
  }
};


/// TypeMatcher for 'type __modf_result_vec'
constexpr TypeMatcher kModfResultVecMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number N = Number::invalid;
  const Type* T = nullptr;
    if (!MatchModfResultVec(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 BuildModfResultVec(state, ty, N, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string N = state->NumName();
  const std::string T = state->TypeName();
    StringStream ss;
    ss << "__modf_result_vec" << N << "_" << T;
    return ss.str();
  }
};


/// TypeMatcher for 'type __frexp_result'
constexpr TypeMatcher kFrexpResultMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  const Type* T = nullptr;
    if (!MatchFrexpResult(state, ty, T)) {
      return nullptr;
    }
    T = state.Type(T);
    if (T == nullptr) {
      return nullptr;
    }
    return BuildFrexpResult(state, ty, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string T = state->TypeName();
    StringStream ss;
    ss << "__frexp_result_" << T;
    return ss.str();
  }
};


/// TypeMatcher for 'type __frexp_result_vec'
constexpr TypeMatcher kFrexpResultVecMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
  Number N = Number::invalid;
  const Type* T = nullptr;
    if (!MatchFrexpResultVec(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 BuildFrexpResultVec(state, ty, N, T);
  },
/* string */ [](MatchState* state) -> std::string {
  const std::string N = state->NumName();
  const std::string T = state->TypeName();
    StringStream ss;
    ss << "__frexp_result_vec" << N << "_" << T;
    return ss.str();
  }
};


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


/// TypeMatcher for 'match scalar'
constexpr TypeMatcher kScalarMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(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 << kIaMatcher.string(nullptr) << ", " << kFaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kF16Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << ", " << kU32Matcher.string(nullptr) << " or " << kBoolMatcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match concrete_scalar'
constexpr TypeMatcher kConcreteScalarMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(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 scalar_no_f32'
constexpr TypeMatcher kScalarNoF32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(state, ty);
    }
    if (MatchBool(state, ty)) {
      return BuildBool(state, ty);
    }
    return nullptr;
  },
/* 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 << kIaMatcher.string(nullptr) << ", " << kFaMatcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << ", " << kF16Matcher.string(nullptr) << ", " << kU32Matcher.string(nullptr) << " or " << kBoolMatcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match scalar_no_f16'
constexpr TypeMatcher kScalarNoF16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(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 << kIaMatcher.string(nullptr) << ", " << kFaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << ", " << kU32Matcher.string(nullptr) << " or " << kBoolMatcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match scalar_no_i32'
constexpr TypeMatcher kScalarNoI32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(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 << kIaMatcher.string(nullptr) << ", " << kFaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kF16Matcher.string(nullptr) << ", " << kU32Matcher.string(nullptr) << " or " << kBoolMatcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match scalar_no_u32'
constexpr TypeMatcher kScalarNoU32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(state, ty);
    }
    if (MatchF16(state, ty)) {
      return BuildF16(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 << kIaMatcher.string(nullptr) << ", " << kFaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kF16Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << " or " << kBoolMatcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match scalar_no_bool'
constexpr TypeMatcher kScalarNoBoolMatcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    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 << kIaMatcher.string(nullptr) << ", " << kFaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kF16Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << " or " << kU32Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fia_fiu32_f16'
constexpr TypeMatcher kFiaFiu32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    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 << kFaMatcher.string(nullptr) << ", " << kIaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << ", " << kU32Matcher.string(nullptr) << " or " << kF16Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fia_fi32_f16'
constexpr TypeMatcher kFiaFi32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    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 << kFaMatcher.string(nullptr) << ", " << kIaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << " or " << kF16Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fia_fiu32'
constexpr TypeMatcher kFiaFiu32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(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 << kFaMatcher.string(nullptr) << ", " << kIaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << " or " << kU32Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fa_f32'
constexpr TypeMatcher kFaF32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(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 << kFaMatcher.string(nullptr) << " or " << kF32Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fa_f32_f16'
constexpr TypeMatcher kFaF32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchFa(state, ty)) {
      return BuildFa(state, ty);
    }
    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 << kFaMatcher.string(nullptr) << ", " << kF32Matcher.string(nullptr) << " or " << kF16Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match ia_iu32'
constexpr TypeMatcher kIaIu32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(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 << kIaMatcher.string(nullptr) << ", " << kI32Matcher.string(nullptr) << " or " << kU32Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match ia_i32'
constexpr TypeMatcher kIaI32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchIa(state, ty)) {
      return BuildIa(state, ty);
    }
    if (MatchI32(state, ty)) {
      return BuildI32(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 << kIaMatcher.string(nullptr) << " or " << kI32Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fiu32_f16'
constexpr TypeMatcher kFiu32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    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) << ", " << kI32Matcher.string(nullptr) << ", " << kU32Matcher.string(nullptr) << " or " << kF16Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fiu32'
constexpr TypeMatcher kFiu32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchU32(state, ty)) {
      return BuildU32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(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 fi32_f16'
constexpr TypeMatcher kFi32F16Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    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) << ", " << kI32Matcher.string(nullptr) << " or " << kF16Matcher.string(nullptr);
    return ss.str();
  }
};

/// TypeMatcher for 'match fi32'
constexpr TypeMatcher kFi32Matcher {
/* match */ [](MatchState& state, const Type* ty) -> const Type* {
    if (MatchI32(state, ty)) {
      return BuildI32(state, ty);
    }
    if (MatchF32(state, ty)) {
      return BuildF32(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 " << kI32Matcher.string(nullptr);
    return ss.str();
  }
};

/// 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();
  }
};

/// 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 write'
constexpr NumberMatcher kWriteMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::Access::kWrite)) {
      return Number(static_cast<uint32_t>(core::Access::kWrite));
    }
    return Number::invalid;
  },
/* string */ [](MatchState*) -> std::string {
    return "write";
  }
};

/// 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 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";
  }
};

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

/// EnumMatcher for 'match function_private_workgroup'
constexpr NumberMatcher kFunctionPrivateWorkgroupMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    switch (static_cast<core::AddressSpace>(number.Value())) {
      case core::AddressSpace::kFunction:
      case core::AddressSpace::kPrivate:
      case core::AddressSpace::kWorkgroup:
        return number;
      default:
        return Number::invalid;
    }
  },
/* string */ [](MatchState*) -> std::string {
    return "function, private or workgroup";
  }
};

/// 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 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'
constexpr NumberMatcher kWorkgroupMatcher {
/* match */ [](MatchState&, Number number) -> Number {
    if (number.IsAny() || number.Value() == static_cast<uint32_t>(core::AddressSpace::kWorkgroup)) {
      return Number(static_cast<uint32_t>(core::AddressSpace::kWorkgroup));
    }
    return Number::invalid;
  },
/* string */ [](MatchState*) -> std::string {
    return "workgroup";
  }
};

/// 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] */ kIaMatcher,
  /* [6] */ kFaMatcher,
  /* [7] */ kI32Matcher,
  /* [8] */ kU32Matcher,
  /* [9] */ kF32Matcher,
  /* [10] */ kF16Matcher,
  /* [11] */ kVec2Matcher,
  /* [12] */ kVec3Matcher,
  /* [13] */ kVec4Matcher,
  /* [14] */ kMat2X2Matcher,
  /* [15] */ kMat2X3Matcher,
  /* [16] */ kMat2X4Matcher,
  /* [17] */ kMat3X2Matcher,
  /* [18] */ kMat3X3Matcher,
  /* [19] */ kMat3X4Matcher,
  /* [20] */ kMat4X2Matcher,
  /* [21] */ kMat4X3Matcher,
  /* [22] */ kMat4X4Matcher,
  /* [23] */ kVecMatcher,
  /* [24] */ kMatMatcher,
  /* [25] */ kPtrMatcher,
  /* [26] */ kAtomicMatcher,
  /* [27] */ kArrayMatcher,
  /* [28] */ kSamplerMatcher,
  /* [29] */ kSamplerComparisonMatcher,
  /* [30] */ kTexture1DMatcher,
  /* [31] */ kTexture2DMatcher,
  /* [32] */ kTexture2DArrayMatcher,
  /* [33] */ kTexture3DMatcher,
  /* [34] */ kTextureCubeMatcher,
  /* [35] */ kTextureCubeArrayMatcher,
  /* [36] */ kTextureMultisampled2DMatcher,
  /* [37] */ kTextureDepth2DMatcher,
  /* [38] */ kTextureDepth2DArrayMatcher,
  /* [39] */ kTextureDepthCubeMatcher,
  /* [40] */ kTextureDepthCubeArrayMatcher,
  /* [41] */ kTextureDepthMultisampled2DMatcher,
  /* [42] */ kTextureStorage1DMatcher,
  /* [43] */ kTextureStorage2DMatcher,
  /* [44] */ kTextureStorage2DArrayMatcher,
  /* [45] */ kTextureStorage3DMatcher,
  /* [46] */ kTextureExternalMatcher,
  /* [47] */ kPackedVec3Matcher,
  /* [48] */ kModfResultMatcher,
  /* [49] */ kModfResultVecMatcher,
  /* [50] */ kFrexpResultMatcher,
  /* [51] */ kFrexpResultVecMatcher,
  /* [52] */ kAtomicCompareExchangeResultMatcher,
  /* [53] */ kScalarMatcher,
  /* [54] */ kConcreteScalarMatcher,
  /* [55] */ kScalarNoF32Matcher,
  /* [56] */ kScalarNoF16Matcher,
  /* [57] */ kScalarNoI32Matcher,
  /* [58] */ kScalarNoU32Matcher,
  /* [59] */ kScalarNoBoolMatcher,
  /* [60] */ kFiaFiu32F16Matcher,
  /* [61] */ kFiaFi32F16Matcher,
  /* [62] */ kFiaFiu32Matcher,
  /* [63] */ kFaF32Matcher,
  /* [64] */ kFaF32F16Matcher,
  /* [65] */ kIaIu32Matcher,
  /* [66] */ kIaI32Matcher,
  /* [67] */ kFiu32F16Matcher,
  /* [68] */ kFiu32Matcher,
  /* [69] */ kFi32F16Matcher,
  /* [70] */ kFi32Matcher,
  /* [71] */ kF32F16Matcher,
  /* [72] */ kIu32Matcher,
};

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

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

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

constexpr NumberMatcherIndex kNumberMatcherIndices[] = {
  /* [0] */ NumberMatcherIndex(12),
  /* [1] */ NumberMatcherIndex(0),
  /* [2] */ NumberMatcherIndex(0),
  /* [3] */ NumberMatcherIndex(1),
  /* [4] */ NumberMatcherIndex(0),
  /* [5] */ NumberMatcherIndex(7),
  /* [6] */ NumberMatcherIndex(13),
  /* [7] */ NumberMatcherIndex(7),
  /* [8] */ NumberMatcherIndex(3),
  /* [9] */ NumberMatcherIndex(9),
  /* [10] */ NumberMatcherIndex(4),
  /* [11] */ NumberMatcherIndex(9),
  /* [12] */ NumberMatcherIndex(5),
  /* [13] */ NumberMatcherIndex(9),
  /* [14] */ NumberMatcherIndex(3),
  /* [15] */ NumberMatcherIndex(8),
  /* [16] */ NumberMatcherIndex(4),
  /* [17] */ NumberMatcherIndex(8),
  /* [18] */ NumberMatcherIndex(5),
  /* [19] */ NumberMatcherIndex(8),
  /* [20] */ NumberMatcherIndex(1),
  /* [21] */ NumberMatcherIndex(2),
  /* [22] */ NumberMatcherIndex(0),
  /* [23] */ NumberMatcherIndex(2),
};

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(3),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(4),
  },
  {
    /* [1] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [2] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [3] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* 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(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [7] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* 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(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [10] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [11] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [12] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* 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(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [15] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [16] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [17] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [18] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [19] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(60),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [20] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [21] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [22] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [23] */
    /* usage */ core::ParameterUsage::kDdx,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [24] */
    /* usage */ core::ParameterUsage::kDdy,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [25] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [26] */
    /* usage */ core::ParameterUsage::kComponent,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [27] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(38),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [28] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [29] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [30] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [31] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [32] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(161),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [33] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(172),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [34] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [35] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [36] */
    /* usage */ core::ParameterUsage::kDepthRef,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [37] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [38] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(60),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [39] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [40] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [41] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [42] */
    /* usage */ core::ParameterUsage::kBias,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [43] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [44] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(58),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [45] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [46] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [47] */
    /* usage */ core::ParameterUsage::kDdx,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [48] */
    /* usage */ core::ParameterUsage::kDdy,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [49] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [50] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(62),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [51] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [52] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [53] */
    /* usage */ core::ParameterUsage::kDdx,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [54] */
    /* usage */ core::ParameterUsage::kDdy,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [55] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(64),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [56] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(68),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [57] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [58] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [59] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [60] */
    /* usage */ core::ParameterUsage::kDdx,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [61] */
    /* usage */ core::ParameterUsage::kDdy,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [62] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(60),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [63] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [64] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [65] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [66] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [67] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [68] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(161),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [69] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [70] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [71] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [72] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [73] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [74] */
    /* usage */ core::ParameterUsage::kComponent,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [75] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(36),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [76] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [77] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [78] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [79] */
    /* usage */ core::ParameterUsage::kComponent,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [80] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(46),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [81] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [82] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [83] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [84] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(161),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [85] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [86] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [87] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [88] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [89] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(160),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [90] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(172),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [91] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [92] */
    /* usage */ core::ParameterUsage::kDepthRef,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [93] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [94] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(163),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [95] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(172),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [96] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [97] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [98] */
    /* usage */ core::ParameterUsage::kDepthRef,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [99] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(60),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [100] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [101] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [102] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [103] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [104] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(58),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [105] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [106] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [107] */
    /* usage */ core::ParameterUsage::kBias,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [108] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [109] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(62),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [110] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [111] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [112] */
    /* usage */ core::ParameterUsage::kBias,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [113] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(64),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [114] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(68),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [115] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [116] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [117] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [118] */
    /* usage */ core::ParameterUsage::kBias,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [119] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(66),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [120] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [121] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [122] */
    /* usage */ core::ParameterUsage::kDdx,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [123] */
    /* usage */ core::ParameterUsage::kDdy,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [124] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(58),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [125] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [126] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [127] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [128] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [129] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(62),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [130] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [131] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [132] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [133] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(64),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [134] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(68),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [135] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [136] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [137] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [138] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [139] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(160),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [140] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [141] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [142] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [143] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [144] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(163),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [145] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [146] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [147] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [148] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [149] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [150] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [151] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [152] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [153] */
    /* usage */ core::ParameterUsage::kComponent,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [154] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(44),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [155] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [156] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [157] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(160),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [158] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [159] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [160] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [161] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(162),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [162] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(172),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [163] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [164] */
    /* usage */ core::ParameterUsage::kDepthRef,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [165] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(58),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [166] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [167] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [168] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [169] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(62),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [170] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [171] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [172] */
    /* usage */ core::ParameterUsage::kOffset,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(64),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [173] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(66),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [174] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [175] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [176] */
    /* usage */ core::ParameterUsage::kBias,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [177] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(66),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [178] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [179] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [180] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [181] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(162),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [182] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [183] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [184] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [185] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(167),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(8),
  },
  {
    /* [186] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [187] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [188] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [189] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(167),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(10),
  },
  {
    /* [190] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [191] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [192] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [193] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(167),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(12),
  },
  {
    /* [194] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [195] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [196] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [197] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(38),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [198] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(76),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [199] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [200] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(173),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [201] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(161),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [202] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [203] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [204] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [205] */
    /* usage */ core::ParameterUsage::kX,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [206] */
    /* usage */ core::ParameterUsage::kY,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [207] */
    /* usage */ core::ParameterUsage::kZ,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [208] */
    /* usage */ core::ParameterUsage::kW,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [209] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [210] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [211] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [212] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [213] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [214] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [215] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [216] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [217] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [218] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [219] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [220] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [221] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [222] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [223] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [224] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [225] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [226] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [227] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [228] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [229] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [230] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [231] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [232] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [233] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [234] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [235] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(56),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [236] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [237] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [238] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(169),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [239] */
    /* usage */ core::ParameterUsage::kSampler,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(170),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [240] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [241] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(165),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(8),
  },
  {
    /* [242] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [243] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [244] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(166),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(8),
  },
  {
    /* [245] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [246] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [247] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(168),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(8),
  },
  {
    /* [248] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [249] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [250] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(165),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(10),
  },
  {
    /* [251] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [252] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [253] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(166),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(10),
  },
  {
    /* [254] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [255] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [256] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(168),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(10),
  },
  {
    /* [257] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [258] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [259] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(165),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(12),
  },
  {
    /* [260] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [261] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [262] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(166),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(12),
  },
  {
    /* [263] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [264] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [265] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(168),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(12),
  },
  {
    /* [266] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [267] */
    /* usage */ core::ParameterUsage::kValue,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [268] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(32),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [269] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [270] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [271] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(36),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [272] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(76),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [273] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [274] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(42),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [275] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(78),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [276] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [277] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(48),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [278] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(76),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [279] */
    /* usage */ core::ParameterUsage::kSampleIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(171),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [280] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(160),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [281] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [282] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [283] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(164),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [284] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [285] */
    /* usage */ core::ParameterUsage::kSampleIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [286] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(167),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(14),
  },
  {
    /* [287] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [288] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [289] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(167),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(16),
  },
  {
    /* [290] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [291] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [292] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(167),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(18),
  },
  {
    /* [293] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [294] */
    /* usage */ core::ParameterUsage::kArrayIndex,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [295] */
    /* usage */ core::ParameterUsage::kXy,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [296] */
    /* usage */ core::ParameterUsage::kZ,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [297] */
    /* usage */ core::ParameterUsage::kW,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [298] */
    /* usage */ core::ParameterUsage::kX,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [299] */
    /* usage */ core::ParameterUsage::kYz,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [300] */
    /* usage */ core::ParameterUsage::kW,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [301] */
    /* usage */ core::ParameterUsage::kX,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [302] */
    /* usage */ core::ParameterUsage::kY,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [303] */
    /* usage */ core::ParameterUsage::kZw,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [304] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [305] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [306] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [307] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(20),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [308] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(32),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [309] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [310] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(36),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [311] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [312] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(38),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [313] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [314] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(42),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [315] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [316] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(44),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [317] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [318] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(46),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [319] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(21),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [320] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(160),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [321] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [322] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(161),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [323] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [324] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(162),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [325] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [326] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(163),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [327] */
    /* usage */ core::ParameterUsage::kLevel,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [328] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(169),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [329] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [330] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(165),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(14),
  },
  {
    /* [331] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [332] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(165),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(16),
  },
  {
    /* [333] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [334] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(165),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(18),
  },
  {
    /* [335] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [336] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(166),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(14),
  },
  {
    /* [337] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [338] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(166),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(16),
  },
  {
    /* [339] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [340] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(166),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(18),
  },
  {
    /* [341] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [342] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(168),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(14),
  },
  {
    /* [343] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [344] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(168),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(16),
  },
  {
    /* [345] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [346] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(168),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(18),
  },
  {
    /* [347] */
    /* usage */ core::ParameterUsage::kCoords,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [348] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [349] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [350] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(82),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [351] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [352] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [353] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [354] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [355] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [356] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(3),
  },
  {
    /* [357] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [358] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(22),
  },
  {
    /* [359] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(3),
  },
  {
    /* [360] */
    /* usage */ core::ParameterUsage::kXy,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [361] */
    /* usage */ core::ParameterUsage::kZw,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [362] */
    /* usage */ core::ParameterUsage::kXyz,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [363] */
    /* usage */ core::ParameterUsage::kW,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [364] */
    /* usage */ core::ParameterUsage::kX,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [365] */
    /* usage */ core::ParameterUsage::kZyw,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [366] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(0),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(0),
  },
  {
    /* [367] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [368] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [369] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(14),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(1),
  },
  {
    /* [370] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [371] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [372] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(30),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(6),
  },
  {
    /* [373] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(165),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [374] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(166),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [375] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(167),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [376] */
    /* usage */ core::ParameterUsage::kTexture,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(168),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(2),
  },
  {
    /* [377] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [378] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(87),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [379] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(76),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [380] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(78),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [381] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(98),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [382] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(104),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [383] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(108),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [384] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(106),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [385] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(110),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [386] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(114),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [387] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(112),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [388] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(116),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [389] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(120),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [390] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(118),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [391] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(122),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [392] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(126),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [393] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(124),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [394] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(128),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [395] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(132),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [396] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(130),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [397] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(134),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [398] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(138),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [399] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(136),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [400] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(140),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [401] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(144),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [402] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(142),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [403] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(146),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [404] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(150),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [405] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(148),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [406] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(152),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [407] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(156),
    /* number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
  },
  {
    /* [408] */
    /* usage */ core::ParameterUsage::kNone,
    /* type_matcher_indices */ TypeMatcherIndicesIndex(154),
    /* 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(68),
  },
  {
    /* [1] */
    /* name */ "C",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [2] */
    /* name */ "A",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [3] */
    /* name */ "L",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [4] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(68),
  },
  {
    /* [5] */
    /* name */ "C",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [6] */
    /* name */ "L",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [7] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(68),
  },
  {
    /* [8] */
    /* name */ "C",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [9] */
    /* name */ "S",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [10] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(64),
  },
  {
    /* [11] */
    /* name */ "U",
    /* matcher_index */ TypeMatcherIndex(66),
  },
  {
    /* [12] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(68),
  },
  {
    /* [13] */
    /* name */ "L",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [14] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(9),
  },
  {
    /* [15] */
    /* name */ "U",
    /* matcher_index */ TypeMatcherIndex(55),
  },
  {
    /* [16] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(10),
  },
  {
    /* [17] */
    /* name */ "U",
    /* matcher_index */ TypeMatcherIndex(56),
  },
  {
    /* [18] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(7),
  },
  {
    /* [19] */
    /* name */ "U",
    /* matcher_index */ TypeMatcherIndex(57),
  },
  {
    /* [20] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(8),
  },
  {
    /* [21] */
    /* name */ "U",
    /* matcher_index */ TypeMatcherIndex(58),
  },
  {
    /* [22] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(4),
  },
  {
    /* [23] */
    /* name */ "U",
    /* matcher_index */ TypeMatcherIndex(59),
  },
  {
    /* [24] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(60),
  },
  {
    /* [25] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(/* invalid */),
  },
  {
    /* [26] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(72),
  },
  {
    /* [27] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(53),
  },
  {
    /* [28] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(61),
  },
  {
    /* [29] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(65),
  },
  {
    /* [30] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(57),
  },
  {
    /* [31] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(58),
  },
  {
    /* [32] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(55),
  },
  {
    /* [33] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(56),
  },
  {
    /* [34] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(59),
  },
  {
    /* [35] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(54),
  },
  {
    /* [36] */
    /* name */ "T",
    /* matcher_index */ TypeMatcherIndex(71),
  },
};

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 */ "M",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [4] */
    /* name */ "N",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [5] */
    /* name */ "M",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [6] */
    /* name */ "F",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [7] */
    /* name */ "A",
    /* matcher_index */ NumberMatcherIndex(/* invalid */),
  },
  {
    /* [8] */
    /* name */ "S",
    /* matcher_index */ NumberMatcherIndex(11),
  },
};

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

constexpr core::constant::Eval::Function kConstEvalFunctions[] = {
  /* [0] */ &core::constant::Eval::abs,
  /* [1] */ &core::constant::Eval::acos,
  /* [2] */ &core::constant::Eval::acosh,
  /* [3] */ &core::constant::Eval::all,
  /* [4] */ &core::constant::Eval::any,
  /* [5] */ &core::constant::Eval::asin,
  /* [6] */ &core::constant::Eval::asinh,
  /* [7] */ &core::constant::Eval::atan,
  /* [8] */ &core::constant::Eval::atan2,
  /* [9] */ &core::constant::Eval::atanh,
  /* [10] */ &core::constant::Eval::ceil,
  /* [11] */ &core::constant::Eval::clamp,
  /* [12] */ &core::constant::Eval::cos,
  /* [13] */ &core::constant::Eval::cosh,
  /* [14] */ &core::constant::Eval::countLeadingZeros,
  /* [15] */ &core::constant::Eval::countOneBits,
  /* [16] */ &core::constant::Eval::countTrailingZeros,
  /* [17] */ &core::constant::Eval::cross,
  /* [18] */ &core::constant::Eval::degrees,
  /* [19] */ &core::constant::Eval::determinant,
  /* [20] */ &core::constant::Eval::distance,
  /* [21] */ &core::constant::Eval::dot,
  /* [22] */ &core::constant::Eval::exp,
  /* [23] */ &core::constant::Eval::exp2,
  /* [24] */ &core::constant::Eval::extractBits,
  /* [25] */ &core::constant::Eval::faceForward,
  /* [26] */ &core::constant::Eval::firstLeadingBit,
  /* [27] */ &core::constant::Eval::firstTrailingBit,
  /* [28] */ &core::constant::Eval::floor,
  /* [29] */ &core::constant::Eval::fma,
  /* [30] */ &core::constant::Eval::fract,
  /* [31] */ &core::constant::Eval::frexp,
  /* [32] */ &core::constant::Eval::insertBits,
  /* [33] */ &core::constant::Eval::inverseSqrt,
  /* [34] */ &core::constant::Eval::ldexp,
  /* [35] */ &core::constant::Eval::length,
  /* [36] */ &core::constant::Eval::log,
  /* [37] */ &core::constant::Eval::log2,
  /* [38] */ &core::constant::Eval::max,
  /* [39] */ &core::constant::Eval::min,
  /* [40] */ &core::constant::Eval::mix,
  /* [41] */ &core::constant::Eval::modf,
  /* [42] */ &core::constant::Eval::normalize,
  /* [43] */ &core::constant::Eval::pack2x16float,
  /* [44] */ &core::constant::Eval::pack2x16snorm,
  /* [45] */ &core::constant::Eval::pack2x16unorm,
  /* [46] */ &core::constant::Eval::pack4x8snorm,
  /* [47] */ &core::constant::Eval::pack4x8unorm,
  /* [48] */ &core::constant::Eval::pow,
  /* [49] */ &core::constant::Eval::quantizeToF16,
  /* [50] */ &core::constant::Eval::radians,
  /* [51] */ &core::constant::Eval::reflect,
  /* [52] */ &core::constant::Eval::refract,
  /* [53] */ &core::constant::Eval::reverseBits,
  /* [54] */ &core::constant::Eval::round,
  /* [55] */ &core::constant::Eval::saturate,
  /* [56] */ &core::constant::Eval::select_bool,
  /* [57] */ &core::constant::Eval::select_boolvec,
  /* [58] */ &core::constant::Eval::sign,
  /* [59] */ &core::constant::Eval::sin,
  /* [60] */ &core::constant::Eval::sinh,
  /* [61] */ &core::constant::Eval::smoothstep,
  /* [62] */ &core::constant::Eval::sqrt,
  /* [63] */ &core::constant::Eval::step,
  /* [64] */ &core::constant::Eval::tan,
  /* [65] */ &core::constant::Eval::tanh,
  /* [66] */ &core::constant::Eval::transpose,
  /* [67] */ &core::constant::Eval::trunc,
  /* [68] */ &core::constant::Eval::unpack2x16float,
  /* [69] */ &core::constant::Eval::unpack2x16snorm,
  /* [70] */ &core::constant::Eval::unpack2x16unorm,
  /* [71] */ &core::constant::Eval::unpack4x8snorm,
  /* [72] */ &core::constant::Eval::unpack4x8unorm,
  /* [73] */ &core::constant::Eval::Identity,
  /* [74] */ &core::constant::Eval::Not,
  /* [75] */ &core::constant::Eval::Complement,
  /* [76] */ &core::constant::Eval::UnaryMinus,
  /* [77] */ &core::constant::Eval::Plus,
  /* [78] */ &core::constant::Eval::Minus,
  /* [79] */ &core::constant::Eval::Multiply,
  /* [80] */ &core::constant::Eval::MultiplyMatVec,
  /* [81] */ &core::constant::Eval::MultiplyVecMat,
  /* [82] */ &core::constant::Eval::MultiplyMatMat,
  /* [83] */ &core::constant::Eval::Divide,
  /* [84] */ &core::constant::Eval::Modulo,
  /* [85] */ &core::constant::Eval::Xor,
  /* [86] */ &core::constant::Eval::And,
  /* [87] */ &core::constant::Eval::Or,
  /* [88] */ &core::constant::Eval::LogicalAnd,
  /* [89] */ &core::constant::Eval::LogicalOr,
  /* [90] */ &core::constant::Eval::Equal,
  /* [91] */ &core::constant::Eval::NotEqual,
  /* [92] */ &core::constant::Eval::LessThan,
  /* [93] */ &core::constant::Eval::GreaterThan,
  /* [94] */ &core::constant::Eval::LessThanEqual,
  /* [95] */ &core::constant::Eval::GreaterThanEqual,
  /* [96] */ &core::constant::Eval::ShiftLeft,
  /* [97] */ &core::constant::Eval::ShiftRight,
  /* [98] */ &core::constant::Eval::Zero,
  /* [99] */ &core::constant::Eval::Conv,
  /* [100] */ &core::constant::Eval::VecSplat,
  /* [101] */ &core::constant::Eval::VecInitS,
  /* [102] */ &core::constant::Eval::VecInitM,
  /* [103] */ &core::constant::Eval::MatInitS,
  /* [104] */ &core::constant::Eval::MatInitV,
};

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

constexpr OverloadInfo kOverloads[] = {
  {
    /* [0] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(268),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [1] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(308),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [2] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(75),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [3] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(310),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [4] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(27),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [5] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(312),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [6] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(274),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(40),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [7] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(314),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(40),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [8] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(154),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [9] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(316),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [10] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(80),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [11] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(12),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(318),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [12] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(277),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [13] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [14] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(3),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(320),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [15] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [16] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(3),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(322),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [17] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(161),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [18] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(3),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(324),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [19] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(94),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [20] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(3),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(326),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [21] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(283),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [22] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(6),
    /* parameters */ ParameterIndex(373),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [23] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(6),
    /* parameters */ ParameterIndex(374),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [24] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(6),
    /* parameters */ ParameterIndex(375),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [25] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(6),
    /* parameters */ ParameterIndex(376),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(40),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [26] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(238),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [27] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(268),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [28] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(271),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [29] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 4,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(197),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [30] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(4),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(274),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [31] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(7),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(277),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [32] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(5),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(280),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [33] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(201),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [34] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(8),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(283),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [35] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(328),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [36] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(330),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [37] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(332),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [38] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(334),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [39] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(336),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [40] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(338),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [41] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(340),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [42] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(286),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [43] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(289),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [44] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(292),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [45] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(342),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [46] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(344),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [47] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(346),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [48] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(96),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [49] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(35),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [50] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(217),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [51] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(100),
  },
  {
    /* [52] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(205),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(101),
  },
  {
    /* [53] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(295),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [54] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(298),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [55] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(301),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [56] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(360),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [57] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(362),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [58] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(364),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [59] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(381),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [60] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(381),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(100),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [61] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(18),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(381),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(72),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [62] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(381),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [63] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(22),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(381),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(102),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [64] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(235),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [65] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(44),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [66] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(165),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [67] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(19),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [68] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(99),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [69] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(50),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [70] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(169),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [71] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(119),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [72] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(56),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [73] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(139),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [74] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(157),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [75] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(68),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [76] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(84),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [77] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(181),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [78] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(144),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [79] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(124),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [80] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(124),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [81] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(62),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [82] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(62),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [83] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(129),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [84] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(129),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [85] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(177),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [86] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(134),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [87] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(3),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(139),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [88] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(3),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(139),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [89] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(68),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [90] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(68),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [91] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(3),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(181),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [92] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(144),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [93] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(74),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [94] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(74),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [95] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(26),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [96] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(26),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [97] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(153),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [98] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 3,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(79),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(50),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [99] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(139),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [100] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(157),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [101] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(68),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [102] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(84),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [103] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(181),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [104] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(144),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [105] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(241),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [106] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(244),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [107] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(185),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [108] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(247),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [109] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(250),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [110] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(253),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [111] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(189),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [112] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(256),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [113] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(259),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [114] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(262),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [115] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 4,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(193),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [116] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(1),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(265),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [117] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(90),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [118] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(35),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [119] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(213),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [120] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(100),
  },
  {
    /* [121] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(205),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(101),
  },
  {
    /* [122] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(295),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [123] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(298),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(102),
  },
  {
    /* [124] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(380),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(54),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [125] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(380),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(92),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [126] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(18),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(380),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(64),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [127] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(380),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(40),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [128] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(22),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(380),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(94),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [129] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(268),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [130] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(75),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [131] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(27),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [132] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(274),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [133] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(154),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [134] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(80),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [135] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [136] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [137] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(161),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [138] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(94),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [139] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(84),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [140] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(35),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [141] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(209),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [142] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(100),
  },
  {
    /* [143] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(205),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(70),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(101),
  },
  {
    /* [144] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(379),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [145] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(379),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(86),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [146] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(18),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(379),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(52),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [147] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(20),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(379),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(34),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [148] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(22),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(379),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(88),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [149] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(79),
  },
  {
    /* [150] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(79),
  },
  {
    /* [151] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(223),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(79),
  },
  {
    /* [152] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(348),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(79),
  },
  {
    /* [153] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(353),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(2),
    /* const_eval_fn */ ConstEvalFunctionIndex(79),
  },
  {
    /* [154] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(352),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(2),
    /* const_eval_fn */ ConstEvalFunctionIndex(79),
  },
  {
    /* [155] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(1),
    /* parameters */ ParameterIndex(354),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(80),
  },
  {
    /* [156] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(1),
    /* parameters */ ParameterIndex(356),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(81),
  },
  {
    /* [157] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 3,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(0),
    /* parameters */ ParameterIndex(358),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(20),
    /* const_eval_fn */ ConstEvalFunctionIndex(82),
  },
  {
    /* [158] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(104),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [159] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(104),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [160] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(38),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [161] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(38),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [162] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(109),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [163] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(109),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [164] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(173),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [165] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(114),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [166] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(44),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [167] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(44),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [168] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(19),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [169] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 7,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(19),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [170] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(50),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [171] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(50),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [172] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(119),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [173] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(56),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [174] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [175] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [176] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [177] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [178] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(161),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [179] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(94),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [180] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [181] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [182] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [183] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [184] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(161),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [185] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(94),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [186] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [187] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(89),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [188] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [189] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [190] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(161),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [191] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 5,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(2),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(94),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [192] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(104),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [193] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(382),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(104),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [194] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(104),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [195] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(209),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(104),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [196] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(383),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(106),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [197] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(384),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(108),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [198] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(110),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [199] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(385),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(110),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [200] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(110),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [201] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(213),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(110),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [202] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(386),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(112),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [203] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(387),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(114),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [204] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(116),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [205] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(388),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(116),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [206] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 8,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(116),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [207] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(217),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(116),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [208] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(389),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(118),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [209] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(390),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(120),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [210] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(122),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [211] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(391),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(122),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [212] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 6,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(122),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [213] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(209),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(122),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [214] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(392),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(124),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [215] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(393),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(126),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [216] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(128),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [217] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(394),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(128),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [218] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 9,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(128),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [219] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(213),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(128),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [220] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(395),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(130),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [221] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(396),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(132),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [222] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(134),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [223] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(397),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(134),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [224] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 12,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(134),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [225] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(217),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(134),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [226] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(398),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(136),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [227] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(399),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(138),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [228] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(140),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [229] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(400),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(140),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [230] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 8,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(140),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [231] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(209),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(140),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [232] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(401),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(142),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [233] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(402),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(144),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [234] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(146),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [235] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(403),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(146),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [236] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 12,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(146),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [237] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(213),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(146),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [238] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(404),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(148),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [239] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(405),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(150),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [240] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(152),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [241] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(36),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(406),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(152),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [242] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 16,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(152),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(103),
  },
  {
    /* [243] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(217),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(152),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(104),
  },
  {
    /* [244] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(16),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(407),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(154),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [245] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(14),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(408),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(156),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [246] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(27),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [247] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(80),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [248] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(32),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [249] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(94),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [250] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(6),
    /* parameters */ ParameterIndex(375),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [251] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(77),
  },
  {
    /* [252] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(77),
  },
  {
    /* [253] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(223),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(77),
  },
  {
    /* [254] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(348),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(77),
  },
  {
    /* [255] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(351),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(2),
    /* const_eval_fn */ ConstEvalFunctionIndex(77),
  },
  {
    /* [256] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(78),
  },
  {
    /* [257] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(78),
  },
  {
    /* [258] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(223),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(78),
  },
  {
    /* [259] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(348),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(78),
  },
  {
    /* [260] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(351),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(2),
    /* const_eval_fn */ ConstEvalFunctionIndex(78),
  },
  {
    /* [261] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(83),
  },
  {
    /* [262] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(83),
  },
  {
    /* [263] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(223),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(83),
  },
  {
    /* [264] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(348),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(83),
  },
  {
    /* [265] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(84),
  },
  {
    /* [266] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(84),
  },
  {
    /* [267] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(223),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(84),
  },
  {
    /* [268] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(348),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(84),
  },
  {
    /* [269] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(86),
  },
  {
    /* [270] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(233),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(86),
  },
  {
    /* [271] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(86),
  },
  {
    /* [272] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(86),
  },
  {
    /* [273] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(87),
  },
  {
    /* [274] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(233),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(87),
  },
  {
    /* [275] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(87),
  },
  {
    /* [276] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(87),
  },
  {
    /* [277] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(40),
  },
  {
    /* [278] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(221),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(40),
  },
  {
    /* [279] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(222),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(40),
  },
  {
    /* [280] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(224),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(56),
  },
  {
    /* [281] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(228),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(56),
  },
  {
    /* [282] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(231),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(57),
  },
  {
    /* [283] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [284] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(377),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [285] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(30),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [286] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [287] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [288] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(31),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [289] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [290] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(368),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [291] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(32),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [292] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(87),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [293] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(378),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(87),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [294] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(33),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(87),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [295] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(98),
  },
  {
    /* [296] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [297] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(34),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
  {
    /* [298] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(0),
  },
  {
    /* [299] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(0),
  },
  {
    /* [300] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(1),
  },
  {
    /* [301] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(1),
  },
  {
    /* [302] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(2),
  },
  {
    /* [303] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(2),
  },
  {
    /* [304] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(3),
  },
  {
    /* [305] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(233),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(3),
  },
  {
    /* [306] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(4),
  },
  {
    /* [307] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(233),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(4),
  },
  {
    /* [308] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(5),
  },
  {
    /* [309] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(5),
  },
  {
    /* [310] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(6),
  },
  {
    /* [311] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(6),
  },
  {
    /* [312] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(7),
  },
  {
    /* [313] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(7),
  },
  {
    /* [314] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(8),
  },
  {
    /* [315] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(8),
  },
  {
    /* [316] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(9),
  },
  {
    /* [317] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(9),
  },
  {
    /* [318] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(10),
  },
  {
    /* [319] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(10),
  },
  {
    /* [320] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(11),
  },
  {
    /* [321] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(221),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(11),
  },
  {
    /* [322] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(12),
  },
  {
    /* [323] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(12),
  },
  {
    /* [324] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(13),
  },
  {
    /* [325] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(13),
  },
  {
    /* [326] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(14),
  },
  {
    /* [327] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(14),
  },
  {
    /* [328] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(15),
  },
  {
    /* [329] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(15),
  },
  {
    /* [330] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(16),
  },
  {
    /* [331] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(16),
  },
  {
    /* [332] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(18),
  },
  {
    /* [333] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(18),
  },
  {
    /* [334] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(20),
  },
  {
    /* [335] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(20),
  },
  {
    /* [336] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(368),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [337] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(369),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(14),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [338] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(22),
  },
  {
    /* [339] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(22),
  },
  {
    /* [340] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(23),
  },
  {
    /* [341] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(23),
  },
  {
    /* [342] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(16),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(24),
  },
  {
    /* [343] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(150),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(24),
  },
  {
    /* [344] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(26),
  },
  {
    /* [345] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(26),
  },
  {
    /* [346] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(27),
  },
  {
    /* [347] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(27),
  },
  {
    /* [348] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(28),
  },
  {
    /* [349] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(28),
  },
  {
    /* [350] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(29),
  },
  {
    /* [351] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(221),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(29),
  },
  {
    /* [352] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(30),
  },
  {
    /* [353] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(30),
  },
  {
    /* [354] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(16),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(31),
  },
  {
    /* [355] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(18),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(31),
  },
  {
    /* [356] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(15),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(32),
  },
  {
    /* [357] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 4,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(32),
  },
  {
    /* [358] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(33),
  },
  {
    /* [359] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(33),
  },
  {
    /* [360] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(304),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(34),
  },
  {
    /* [361] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 2,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(306),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(34),
  },
  {
    /* [362] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(35),
  },
  {
    /* [363] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(35),
  },
  {
    /* [364] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(36),
  },
  {
    /* [365] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(36),
  },
  {
    /* [366] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(37),
  },
  {
    /* [367] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(37),
  },
  {
    /* [368] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(38),
  },
  {
    /* [369] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(38),
  },
  {
    /* [370] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(39),
  },
  {
    /* [371] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(39),
  },
  {
    /* [372] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(22),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(41),
  },
  {
    /* [373] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(24),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(41),
  },
  {
    /* [374] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(48),
  },
  {
    /* [375] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(48),
  },
  {
    /* [376] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(368),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(49),
  },
  {
    /* [377] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(369),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(14),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(49),
  },
  {
    /* [378] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(50),
  },
  {
    /* [379] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(50),
  },
  {
    /* [380] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(53),
  },
  {
    /* [381] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(53),
  },
  {
    /* [382] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(54),
  },
  {
    /* [383] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(54),
  },
  {
    /* [384] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(55),
  },
  {
    /* [385] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(55),
  },
  {
    /* [386] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(28),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(58),
  },
  {
    /* [387] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(28),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(58),
  },
  {
    /* [388] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(59),
  },
  {
    /* [389] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(59),
  },
  {
    /* [390] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(60),
  },
  {
    /* [391] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(60),
  },
  {
    /* [392] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(61),
  },
  {
    /* [393] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(221),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(61),
  },
  {
    /* [394] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(62),
  },
  {
    /* [395] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(62),
  },
  {
    /* [396] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(63),
  },
  {
    /* [397] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(63),
  },
  {
    /* [398] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(64),
  },
  {
    /* [399] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(64),
  },
  {
    /* [400] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(65),
  },
  {
    /* [401] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(65),
  },
  {
    /* [402] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(67),
  },
  {
    /* [403] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(67),
  },
  {
    /* [404] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(0),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(277),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [405] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(283),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [406] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(44),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [407] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(238),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [408] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(74),
  },
  {
    /* [409] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(233),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(74),
  },
  {
    /* [410] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(75),
  },
  {
    /* [411] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(75),
  },
  {
    /* [412] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(28),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(76),
  },
  {
    /* [413] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(28),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(76),
  },
  {
    /* [414] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(85),
  },
  {
    /* [415] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(85),
  },
  {
    /* [416] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(90),
  },
  {
    /* [417] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(90),
  },
  {
    /* [418] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(91),
  },
  {
    /* [419] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(27),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(91),
  },
  {
    /* [420] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(92),
  },
  {
    /* [421] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(92),
  },
  {
    /* [422] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(93),
  },
  {
    /* [423] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(93),
  },
  {
    /* [424] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(94),
  },
  {
    /* [425] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(94),
  },
  {
    /* [426] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(95),
  },
  {
    /* [427] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(8),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(95),
  },
  {
    /* [428] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(16),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(96),
  },
  {
    /* [429] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(349),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(96),
  },
  {
    /* [430] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(16),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(97),
  },
  {
    /* [431] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(29),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(349),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(97),
  },
  {
    /* [432] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(25),
    /* template_numbers */ TemplateNumberIndex(7),
    /* parameters */ ParameterIndex(366),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [433] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(213),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(17),
  },
  {
    /* [434] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(367),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(19),
  },
  {
    /* [435] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(24),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(21),
  },
  {
    /* [436] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(53),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [437] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [438] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(221),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(25),
  },
  {
    /* [439] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(42),
  },
  {
    /* [440] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(370),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(43),
  },
  {
    /* [441] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(370),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(44),
  },
  {
    /* [442] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(370),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(45),
  },
  {
    /* [443] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(371),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(46),
  },
  {
    /* [444] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(371),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(35),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(47),
  },
  {
    /* [445] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(149),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(51),
  },
  {
    /* [446] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(4),
    /* parameters */ ParameterIndex(222),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(1),
    /* const_eval_fn */ ConstEvalFunctionIndex(52),
  },
  {
    /* [447] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [448] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 2,
    /* template_types */ TemplateTypeIndex(10),
    /* template_numbers */ TemplateNumberIndex(3),
    /* parameters */ ParameterIndex(351),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(12),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(3),
    /* const_eval_fn */ ConstEvalFunctionIndex(66),
  },
  {
    /* [449] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(68),
  },
  {
    /* [450] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(69),
  },
  {
    /* [451] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(26),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(70),
  },
  {
    /* [452] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(71),
  },
  {
    /* [453] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(17),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(28),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(72),
  },
  {
    /* [454] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(25),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(372),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [455] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(8),
    /* parameters */ ParameterIndex(0),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [456] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(8),
    /* parameters */ ParameterIndex(0),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(/* invalid */),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [457] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 2,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(8),
    /* parameters */ ParameterIndex(0),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [458] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 3,
    /* num_template_types */ 1,
    /* num_template_numbers */ 1,
    /* template_types */ TemplateTypeIndex(26),
    /* template_numbers */ TemplateNumberIndex(8),
    /* parameters */ ParameterIndex(0),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(80),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [459] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 0,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(/* invalid */),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(74),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */),
  },
  {
    /* [460] */
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(25),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(1),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(73),
  },
  {
    /* [461] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(88),
  },
  {
    /* [462] */
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 2,
    /* num_template_types */ 0,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(/* invalid */),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(226),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(89),
  },
  {
    /* [463] */
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse),
    /* num_parameters */ 1,
    /* num_template_types */ 1,
    /* num_template_numbers */ 0,
    /* template_types */ TemplateTypeIndex(35),
    /* template_numbers */ TemplateNumberIndex(/* invalid */),
    /* parameters */ ParameterIndex(213),
    /* return_type_matcher_indices */ TypeMatcherIndicesIndex(158),
    /* return_number_matcher_indices */ NumberMatcherIndicesIndex(/* invalid */),
    /* const_eval_fn */ ConstEvalFunctionIndex(99),
  },
};

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

constexpr IntrinsicInfo kBuiltins[] = {
  {
    /* [0] */
    /* fn abs<T : fia_fiu32_f16>(T) -> T */
    /* fn abs<N : num, T : fia_fiu32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(298),
  },
  {
    /* [1] */
    /* fn acos<T : fa_f32_f16>(@test_value(0.96891242171) T) -> T */
    /* fn acos<N : num, T : fa_f32_f16>(@test_value(0.96891242171) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(300),
  },
  {
    /* [2] */
    /* fn acosh<T : fa_f32_f16>(@test_value(1.5430806348) T) -> T */
    /* fn acosh<N : num, T : fa_f32_f16>(@test_value(1.5430806348) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(302),
  },
  {
    /* [3] */
    /* fn all(bool) -> bool */
    /* fn all<N : num>(vec<N, bool>) -> bool */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(304),
  },
  {
    /* [4] */
    /* fn any(bool) -> bool */
    /* fn any<N : num>(vec<N, bool>) -> bool */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(306),
  },
  {
    /* [5] */
    /* fn arrayLength<T, A : access>(ptr<storage, array<T>, A>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(432),
  },
  {
    /* [6] */
    /* fn asin<T : fa_f32_f16>(@test_value(0.479425538604) T) -> T */
    /* fn asin<N : num, T : fa_f32_f16>(@test_value(0.479425538604) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(308),
  },
  {
    /* [7] */
    /* fn asinh<T : fa_f32_f16>(T) -> T */
    /* fn asinh<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(310),
  },
  {
    /* [8] */
    /* fn atan<T : fa_f32_f16>(T) -> T */
    /* fn atan<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(312),
  },
  {
    /* [9] */
    /* fn atan2<T : fa_f32_f16>(T, T) -> T */
    /* fn atan2<T : fa_f32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(314),
  },
  {
    /* [10] */
    /* fn atanh<T : fa_f32_f16>(@test_value(0.5) T) -> T */
    /* fn atanh<N : num, T : fa_f32_f16>(@test_value(0.5) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(316),
  },
  {
    /* [11] */
    /* fn ceil<T : fa_f32_f16>(@test_value(1.5) T) -> T */
    /* fn ceil<N : num, T : fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(318),
  },
  {
    /* [12] */
    /* fn clamp<T : fia_fiu32_f16>(T, T, T) -> T */
    /* fn clamp<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(320),
  },
  {
    /* [13] */
    /* fn cos<T : fa_f32_f16>(@test_value(0) T) -> T */
    /* fn cos<N : num, T : fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(322),
  },
  {
    /* [14] */
    /* fn cosh<T : fa_f32_f16>(@test_value(0) T) -> T */
    /* fn cosh<N : num, T : fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(324),
  },
  {
    /* [15] */
    /* fn countLeadingZeros<T : iu32>(T) -> T */
    /* fn countLeadingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(326),
  },
  {
    /* [16] */
    /* fn countOneBits<T : iu32>(T) -> T */
    /* fn countOneBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(328),
  },
  {
    /* [17] */
    /* fn countTrailingZeros<T : iu32>(T) -> T */
    /* fn countTrailingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(330),
  },
  {
    /* [18] */
    /* fn cross<T : fa_f32_f16>(vec3<T>, vec3<T>) -> vec3<T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(433),
  },
  {
    /* [19] */
    /* fn degrees<T : fa_f32_f16>(T) -> T */
    /* fn degrees<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(332),
  },
  {
    /* [20] */
    /* fn determinant<N : num, T : fa_f32_f16>(mat<N, N, T>) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(434),
  },
  {
    /* [21] */
    /* fn distance<T : fa_f32_f16>(T, T) -> T */
    /* fn distance<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> T */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(334),
  },
  {
    /* [22] */
    /* fn dot<N : num, T : fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(435),
  },
  {
    /* [23] */
    /* fn dot4I8Packed(u32, u32) -> i32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(436),
  },
  {
    /* [24] */
    /* fn dot4U8Packed(u32, u32) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(437),
  },
  {
    /* [25] */
    /* fn dpdx(f32) -> f32 */
    /* fn dpdx<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [26] */
    /* fn dpdxCoarse(f32) -> f32 */
    /* fn dpdxCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [27] */
    /* fn dpdxFine(f32) -> f32 */
    /* fn dpdxFine<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [28] */
    /* fn dpdy(f32) -> f32 */
    /* fn dpdy<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [29] */
    /* fn dpdyCoarse(f32) -> f32 */
    /* fn dpdyCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [30] */
    /* fn dpdyFine(f32) -> f32 */
    /* fn dpdyFine<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [31] */
    /* fn exp<T : fa_f32_f16>(T) -> T */
    /* fn exp<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(338),
  },
  {
    /* [32] */
    /* fn exp2<T : fa_f32_f16>(T) -> T */
    /* fn exp2<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(340),
  },
  {
    /* [33] */
    /* fn extractBits<T : iu32>(T, u32, u32) -> T */
    /* fn extractBits<N : num, T : iu32>(vec<N, T>, u32, u32) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(342),
  },
  {
    /* [34] */
    /* fn faceForward<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(438),
  },
  {
    /* [35] */
    /* fn firstLeadingBit<T : iu32>(T) -> T */
    /* fn firstLeadingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(344),
  },
  {
    /* [36] */
    /* fn firstTrailingBit<T : iu32>(T) -> T */
    /* fn firstTrailingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(346),
  },
  {
    /* [37] */
    /* fn floor<T : fa_f32_f16>(@test_value(1.5) T) -> T */
    /* fn floor<N : num, T : fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(348),
  },
  {
    /* [38] */
    /* fn fma<T : fa_f32_f16>(T, T, T) -> T */
    /* fn fma<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(350),
  },
  {
    /* [39] */
    /* fn fract<T : fa_f32_f16>(@test_value(1.25) T) -> T */
    /* fn fract<N : num, T : fa_f32_f16>(@test_value(1.25) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(352),
  },
  {
    /* [40] */
    /* fn frexp<T : fa_f32_f16>(T) -> __frexp_result<T> */
    /* fn frexp<N : num, T : fa_f32_f16>(vec<N, T>) -> __frexp_result_vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(354),
  },
  {
    /* [41] */
    /* fn fwidth(f32) -> f32 */
    /* fn fwidth<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [42] */
    /* fn fwidthCoarse(f32) -> f32 */
    /* fn fwidthCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [43] */
    /* fn fwidthFine(f32) -> f32 */
    /* fn fwidthFine<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(336),
  },
  {
    /* [44] */
    /* fn insertBits<T : iu32>(T, T, u32, u32) -> T */
    /* fn insertBits<N : num, T : iu32>(vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(356),
  },
  {
    /* [45] */
    /* fn inverseSqrt<T : fa_f32_f16>(T) -> T */
    /* fn inverseSqrt<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(358),
  },
  {
    /* [46] */
    /* fn ldexp<T : fa_f32_f16, U : ia_i32>(T, U) -> T */
    /* fn ldexp<N : num, T : fa_f32_f16, U : ia_i32>(vec<N, T>, vec<N, U>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(360),
  },
  {
    /* [47] */
    /* fn length<T : fa_f32_f16>(@test_value(0) T) -> T */
    /* fn length<N : num, T : fa_f32_f16>(@test_value(0) vec<N, T>) -> T */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(362),
  },
  {
    /* [48] */
    /* fn log<T : fa_f32_f16>(T) -> T */
    /* fn log<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(364),
  },
  {
    /* [49] */
    /* fn log2<T : fa_f32_f16>(T) -> T */
    /* fn log2<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(366),
  },
  {
    /* [50] */
    /* fn max<T : fia_fiu32_f16>(T, T) -> T */
    /* fn max<N : num, T : fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(368),
  },
  {
    /* [51] */
    /* fn min<T : fia_fiu32_f16>(T, T) -> T */
    /* fn min<N : num, T : fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(370),
  },
  {
    /* [52] */
    /* fn mix<T : fa_f32_f16>(T, T, T) -> T */
    /* fn mix<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* fn mix<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> */
    /* num overloads */ 3,
    /* overloads */ OverloadIndex(277),
  },
  {
    /* [53] */
    /* fn modf<T : fa_f32_f16>(@test_value(-1.5) T) -> __modf_result<T> */
    /* fn modf<N : num, T : fa_f32_f16>(@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(372),
  },
  {
    /* [54] */
    /* fn normalize<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(439),
  },
  {
    /* [55] */
    /* fn pack2x16float(vec2<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(440),
  },
  {
    /* [56] */
    /* fn pack2x16snorm(vec2<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(441),
  },
  {
    /* [57] */
    /* fn pack2x16unorm(vec2<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(442),
  },
  {
    /* [58] */
    /* fn pack4x8snorm(vec4<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(443),
  },
  {
    /* [59] */
    /* fn pack4x8unorm(vec4<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(444),
  },
  {
    /* [60] */
    /* fn pow<T : fa_f32_f16>(T, T) -> T */
    /* fn pow<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(374),
  },
  {
    /* [61] */
    /* fn quantizeToF16(f32) -> f32 */
    /* fn quantizeToF16<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(376),
  },
  {
    /* [62] */
    /* fn radians<T : fa_f32_f16>(T) -> T */
    /* fn radians<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(378),
  },
  {
    /* [63] */
    /* fn reflect<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(445),
  },
  {
    /* [64] */
    /* fn refract<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(446),
  },
  {
    /* [65] */
    /* fn reverseBits<T : iu32>(T) -> T */
    /* fn reverseBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(380),
  },
  {
    /* [66] */
    /* fn round<T : fa_f32_f16>(@test_value(3.5) T) -> T */
    /* fn round<N : num, T : fa_f32_f16>(@test_value(3.5) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(382),
  },
  {
    /* [67] */
    /* fn saturate<T : fa_f32_f16>(@test_value(2) T) -> T */
    /* fn saturate<T : fa_f32_f16, N : num>(@test_value(2) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(384),
  },
  {
    /* [68] */
    /* fn select<T : scalar>(T, T, bool) -> T */
    /* fn select<T : scalar, N : num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T> */
    /* fn select<N : num, T : scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T> */
    /* num overloads */ 3,
    /* overloads */ OverloadIndex(280),
  },
  {
    /* [69] */
    /* fn sign<T : fia_fi32_f16>(T) -> T */
    /* fn sign<N : num, T : fia_fi32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(386),
  },
  {
    /* [70] */
    /* fn sin<T : fa_f32_f16>(@test_value(1.57079632679) T) -> T */
    /* fn sin<N : num, T : fa_f32_f16>(@test_value(1.57079632679) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(388),
  },
  {
    /* [71] */
    /* fn sinh<T : fa_f32_f16>(T) -> T */
    /* fn sinh<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(390),
  },
  {
    /* [72] */
    /* fn smoothstep<T : fa_f32_f16>(@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T */
    /* fn smoothstep<N : num, T : fa_f32_f16>(@test_value(2) vec<N, T>, @test_value(4) vec<N, T>, @test_value(3) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(392),
  },
  {
    /* [73] */
    /* fn sqrt<T : fa_f32_f16>(T) -> T */
    /* fn sqrt<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(394),
  },
  {
    /* [74] */
    /* fn step<T : fa_f32_f16>(T, T) -> T */
    /* fn step<N : num, T : fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(396),
  },
  {
    /* [75] */
    /* fn storageBarrier() */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(447),
  },
  {
    /* [76] */
    /* fn tan<T : fa_f32_f16>(T) -> T */
    /* fn tan<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(398),
  },
  {
    /* [77] */
    /* fn tanh<T : fa_f32_f16>(T) -> T */
    /* fn tanh<N : num, T : fa_f32_f16>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(400),
  },
  {
    /* [78] */
    /* fn transpose<M : num, N : num, T : fa_f32_f16>(mat<M, N, T>) -> mat<N, M, T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(448),
  },
  {
    /* [79] */
    /* fn trunc<T : fa_f32_f16>(@test_value(1.5) T) -> T */
    /* fn trunc<N : num, T : fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(402),
  },
  {
    /* [80] */
    /* fn unpack2x16float(u32) -> vec2<f32> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(449),
  },
  {
    /* [81] */
    /* fn unpack2x16snorm(u32) -> vec2<f32> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(450),
  },
  {
    /* [82] */
    /* fn unpack2x16unorm(u32) -> vec2<f32> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(451),
  },
  {
    /* [83] */
    /* fn unpack4x8snorm(u32) -> vec4<f32> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(452),
  },
  {
    /* [84] */
    /* fn unpack4x8unorm(u32) -> vec4<f32> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(453),
  },
  {
    /* [85] */
    /* fn workgroupBarrier() */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(447),
  },
  {
    /* [86] */
    /* fn workgroupUniformLoad<T>(ptr<workgroup, T, read_write>) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(454),
  },
  {
    /* [87] */
    /* fn textureBarrier() */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(447),
  },
  {
    /* [88] */
    /* fn textureDimensions<T : fiu32>(texture: texture_1d<T>) -> u32 */
    /* fn textureDimensions<T : fiu32, L : iu32>(texture: texture_1d<T>, level: L) -> u32 */
    /* fn textureDimensions<T : fiu32>(texture: texture_2d<T>) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32, L : iu32>(texture: texture_2d<T>, level: L) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_2d_array<T>) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32, L : iu32>(texture: texture_2d_array<T>, level: L) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_3d<T>) -> vec3<u32> */
    /* fn textureDimensions<T : fiu32, L : iu32>(texture: texture_3d<T>, level: L) -> vec3<u32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_cube<T>) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32, L : iu32>(texture: texture_cube<T>, level: L) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_cube_array<T>) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32, L : iu32>(texture: texture_cube_array<T>, level: L) -> vec2<u32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_multisampled_2d<T>) -> vec2<u32> */
    /* fn textureDimensions(texture: texture_depth_2d) -> vec2<u32> */
    /* fn textureDimensions<L : iu32>(texture: texture_depth_2d, level: L) -> vec2<u32> */
    /* fn textureDimensions(texture: texture_depth_2d_array) -> vec2<u32> */
    /* fn textureDimensions<L : iu32>(texture: texture_depth_2d_array, level: L) -> vec2<u32> */
    /* fn textureDimensions(texture: texture_depth_cube) -> vec2<u32> */
    /* fn textureDimensions<L : iu32>(texture: texture_depth_cube, level: L) -> vec2<u32> */
    /* fn textureDimensions(texture: texture_depth_cube_array) -> vec2<u32> */
    /* fn textureDimensions<L : iu32>(texture: texture_depth_cube_array, level: L) -> vec2<u32> */
    /* fn textureDimensions(texture: texture_depth_multisampled_2d) -> vec2<u32> */
    /* fn textureDimensions<F : texel_format, A : access>(texture: texture_storage_1d<F, A>) -> u32 */
    /* fn textureDimensions<F : texel_format, A : access>(texture: texture_storage_2d<F, A>) -> vec2<u32> */
    /* fn textureDimensions<F : texel_format, A : access>(texture: texture_storage_2d_array<F, A>) -> vec2<u32> */
    /* fn textureDimensions<F : texel_format, A : access>(texture: texture_storage_3d<F, A>) -> vec3<u32> */
    /* fn textureDimensions(texture: texture_external) -> vec2<u32> */
    /* num overloads */ 27,
    /* overloads */ OverloadIndex(0),
  },
  {
    /* [89] */
    /* fn textureGather<T : fiu32, C : iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T> */
    /* fn textureGather<T : fiu32, C : iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T> */
    /* fn textureGather<T : fiu32, C : iu32, A : iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<T> */
    /* fn textureGather<T : fiu32, C : iu32, A : iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<T> */
    /* fn textureGather<T : fiu32, C : iu32>(@const component: C, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T> */
    /* fn textureGather<T : fiu32, C : iu32, A : iu32>(@const component: C, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<T> */
    /* fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
    /* fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGather<A : iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32> */
    /* fn textureGather<A : iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> vec4<f32> */
    /* fn textureGather<A : iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32> */
    /* num overloads */ 12,
    /* overloads */ OverloadIndex(93),
  },
  {
    /* [90] */
    /* fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> vec4<f32> */
    /* fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGatherCompare<A : iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> vec4<f32> */
    /* fn textureGatherCompare<A : iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32> */
    /* fn textureGatherCompare<A : iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(174),
  },
  {
    /* [91] */
    /* fn textureNumLayers<T : fiu32>(texture: texture_2d_array<T>) -> u32 */
    /* fn textureNumLayers<T : fiu32>(texture: texture_cube_array<T>) -> u32 */
    /* fn textureNumLayers(texture: texture_depth_2d_array) -> u32 */
    /* fn textureNumLayers(texture: texture_depth_cube_array) -> u32 */
    /* fn textureNumLayers<F : texel_format, A : access>(texture: texture_storage_2d_array<F, A>) -> u32 */
    /* num overloads */ 5,
    /* overloads */ OverloadIndex(246),
  },
  {
    /* [92] */
    /* fn textureNumLevels<T : fiu32>(texture: texture_1d<T>) -> u32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_2d<T>) -> u32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_2d_array<T>) -> u32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_3d<T>) -> u32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_cube<T>) -> u32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_cube_array<T>) -> u32 */
    /* fn textureNumLevels(texture: texture_depth_2d) -> u32 */
    /* fn textureNumLevels(texture: texture_depth_2d_array) -> u32 */
    /* fn textureNumLevels(texture: texture_depth_cube) -> u32 */
    /* fn textureNumLevels(texture: texture_depth_cube_array) -> u32 */
    /* num overloads */ 10,
    /* overloads */ OverloadIndex(129),
  },
  {
    /* [93] */
    /* fn textureNumSamples<T : fiu32>(texture: texture_multisampled_2d<T>) -> u32 */
    /* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32 */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(404),
  },
  {
    /* [94] */
    /* fn textureSample(texture: texture_1d<f32>, sampler: sampler, coords: f32) -> vec4<f32> */
    /* fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
    /* fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSample<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32> */
    /* fn textureSample<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32> */
    /* fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32> */
    /* fn textureSample(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32> */
    /* fn textureSample<A : iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32> */
    /* fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> f32 */
    /* fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> f32 */
    /* fn textureSample<A : iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> f32 */
    /* fn textureSample<A : iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> f32 */
    /* fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> f32 */
    /* fn textureSample<A : iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> f32 */
    /* num overloads */ 15,
    /* overloads */ OverloadIndex(64),
  },
  {
    /* [95] */
    /* fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleBias<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32) -> vec4<f32> */
    /* fn textureSampleBias<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32, @const offset: vec3<i32>) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32> */
    /* fn textureSampleBias<A : iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, bias: f32) -> vec4<f32> */
    /* num overloads */ 8,
    /* overloads */ OverloadIndex(158),
  },
  {
    /* [96] */
    /* fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32 */
    /* fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompare<A : iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32 */
    /* fn textureSampleCompare<A : iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
    /* fn textureSampleCompare<A : iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32 */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(180),
  },
  {
    /* [97] */
    /* fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32 */
    /* fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompareLevel<A : iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32 */
    /* fn textureSampleCompareLevel<A : iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
    /* fn textureSampleCompareLevel<A : iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32 */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(186),
  },
  {
    /* [98] */
    /* fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32> */
    /* fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleGrad<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32> */
    /* fn textureSampleGrad<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> */
    /* fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32> */
    /* fn textureSampleGrad(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> */
    /* fn textureSampleGrad<A : iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> */
    /* num overloads */ 8,
    /* overloads */ OverloadIndex(166),
  },
  {
    /* [99] */
    /* fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleLevel<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel<A : iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32, @const offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32, @const offset: vec3<i32>) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel<A : iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel<L : iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L) -> f32 */
    /* fn textureSampleLevel<L : iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L, @const offset: vec2<i32>) -> f32 */
    /* fn textureSampleLevel<A : iu32, L : iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L) -> f32 */
    /* fn textureSampleLevel<A : iu32, L : iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L, @const offset: vec2<i32>) -> f32 */
    /* fn textureSampleLevel<L : iu32>(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: L) -> f32 */
    /* fn textureSampleLevel<A : iu32, L : iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A, level: L) -> f32 */
    /* num overloads */ 14,
    /* overloads */ OverloadIndex(79),
  },
  {
    /* [100] */
    /* fn textureSampleBaseClampToEdge(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
    /* fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(406),
  },
  {
    /* [101] */
    /* fn textureStore<C : iu32>(texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>) */
    /* fn textureStore<C : iu32, A : iu32>(texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<f32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>) */
    /* fn textureStore<C : iu32, A : iu32>(texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<i32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>) */
    /* fn textureStore<C : iu32, A : iu32>(texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<u32>) */
    /* fn textureStore<C : iu32>(texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>) */
    /* num overloads */ 12,
    /* overloads */ OverloadIndex(105),
  },
  {
    /* [102] */
    /* fn textureLoad<T : fiu32, C : iu32, L : iu32>(texture: texture_1d<T>, coords: C, level: L) -> vec4<T> */
    /* fn textureLoad<T : fiu32, C : iu32, L : iu32>(texture: texture_2d<T>, coords: vec2<C>, level: L) -> vec4<T> */
    /* fn textureLoad<T : fiu32, C : iu32, A : iu32, L : iu32>(texture: texture_2d_array<T>, coords: vec2<C>, array_index: A, level: L) -> vec4<T> */
    /* fn textureLoad<T : fiu32, C : iu32, L : iu32>(texture: texture_3d<T>, coords: vec3<C>, level: L) -> vec4<T> */
    /* fn textureLoad<T : fiu32, C : iu32, S : iu32>(texture: texture_multisampled_2d<T>, coords: vec2<C>, sample_index: S) -> vec4<T> */
    /* fn textureLoad<C : iu32, L : iu32>(texture: texture_depth_2d, coords: vec2<C>, level: L) -> f32 */
    /* fn textureLoad<C : iu32, A : iu32, L : iu32>(texture: texture_depth_2d_array, coords: vec2<C>, array_index: A, level: L) -> f32 */
    /* fn textureLoad<C : iu32, S : iu32>(texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: S) -> f32 */
    /* fn textureLoad<C : iu32>(texture: texture_external, coords: vec2<C>) -> vec4<f32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_1d<f32_texel_format, readable>, coords: C) -> vec4<f32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_1d<i32_texel_format, readable>, coords: C) -> vec4<i32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_1d<u32_texel_format, readable>, coords: C) -> vec4<u32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_2d<f32_texel_format, readable>, coords: vec2<C>) -> vec4<f32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_2d<i32_texel_format, readable>, coords: vec2<C>) -> vec4<i32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_2d<u32_texel_format, readable>, coords: vec2<C>) -> vec4<u32> */
    /* fn textureLoad<C : iu32, A : iu32>(texture: texture_storage_2d_array<f32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<f32> */
    /* fn textureLoad<C : iu32, A : iu32>(texture: texture_storage_2d_array<i32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<i32> */
    /* fn textureLoad<C : iu32, A : iu32>(texture: texture_storage_2d_array<u32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<u32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_3d<f32_texel_format, readable>, coords: vec3<C>) -> vec4<f32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_3d<i32_texel_format, readable>, coords: vec3<C>) -> vec4<i32> */
    /* fn textureLoad<C : iu32>(texture: texture_storage_3d<u32_texel_format, readable>, coords: vec3<C>) -> vec4<u32> */
    /* num overloads */ 21,
    /* overloads */ OverloadIndex(27),
  },
  {
    /* [103] */
    /* fn atomicLoad<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(455),
  },
  {
    /* [104] */
    /* fn atomicStore<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(456),
  },
  {
    /* [105] */
    /* fn atomicAdd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [106] */
    /* fn atomicSub<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [107] */
    /* fn atomicMax<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [108] */
    /* fn atomicMin<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [109] */
    /* fn atomicAnd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [110] */
    /* fn atomicOr<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [111] */
    /* fn atomicXor<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [112] */
    /* fn atomicExchange<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(457),
  },
  {
    /* [113] */
    /* fn atomicCompareExchangeWeak<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(458),
  },
  {
    /* [114] */
    /* fn subgroupBallot() -> vec4<u32> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(459),
  },
  {
    /* [115] */
    /* fn _tint_materialize<T>(T) -> T */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(460),
  },
};

constexpr IntrinsicInfo kUnaryOperators[] = {
  {
    /* [0] */
    /* op !(bool) -> bool */
    /* op !<N : num>(vec<N, bool>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(408),
  },
  {
    /* [1] */
    /* op ~<T : ia_iu32>(T) -> T */
    /* op ~<T : ia_iu32, N : num>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(410),
  },
  {
    /* [2] */
    /* op -<T : fia_fi32_f16>(T) -> T */
    /* op -<T : fia_fi32_f16, N : num>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(412),
  },
};
constexpr uint8_t kUnaryOperatorNot = 0;
constexpr uint8_t kUnaryOperatorComplement = 1;
constexpr uint8_t kUnaryOperatorMinus = 2;

constexpr IntrinsicInfo kBinaryOperators[] = {
  {
    /* [0] */
    /* op +<T : fia_fiu32_f16>(T, T) -> T */
    /* op +<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op +<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op +<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* op +<T : fa_f32_f16, N : num, M : num>(mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> */
    /* num overloads */ 5,
    /* overloads */ OverloadIndex(251),
  },
  {
    /* [1] */
    /* op -<T : fia_fiu32_f16>(T, T) -> T */
    /* op -<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op -<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op -<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* op -<T : fa_f32_f16, N : num, M : num>(mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> */
    /* num overloads */ 5,
    /* overloads */ OverloadIndex(256),
  },
  {
    /* [2] */
    /* op *<T : fia_fiu32_f16>(T, T) -> T */
    /* op *<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op *<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op *<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* op *<T : fa_f32_f16, N : num, M : num>(T, mat<N, M, T>) -> mat<N, M, T> */
    /* op *<T : fa_f32_f16, N : num, M : num>(mat<N, M, T>, T) -> mat<N, M, T> */
    /* op *<T : fa_f32_f16, C : num, R : num>(mat<C, R, T>, vec<C, T>) -> vec<R, T> */
    /* op *<T : fa_f32_f16, C : num, R : num>(vec<R, T>, mat<C, R, T>) -> vec<C, T> */
    /* op *<T : fa_f32_f16, K : num, C : num, R : num>(mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T> */
    /* num overloads */ 9,
    /* overloads */ OverloadIndex(149),
  },
  {
    /* [3] */
    /* op /<T : fia_fiu32_f16>(T, T) -> T */
    /* op /<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op /<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op /<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ OverloadIndex(261),
  },
  {
    /* [4] */
    /* op %<T : fia_fiu32_f16>(T, T) -> T */
    /* op %<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op %<T : fia_fiu32_f16, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op %<T : fia_fiu32_f16, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ OverloadIndex(265),
  },
  {
    /* [5] */
    /* op ^<T : ia_iu32>(T, T) -> T */
    /* op ^<T : ia_iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(414),
  },
  {
    /* [6] */
    /* op &(bool, bool) -> bool */
    /* op &<N : num>(vec<N, bool>, vec<N, bool>) -> vec<N, bool> */
    /* op &<T : ia_iu32>(T, T) -> T */
    /* op &<T : ia_iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ OverloadIndex(269),
  },
  {
    /* [7] */
    /* op |(bool, bool) -> bool */
    /* op |<N : num>(vec<N, bool>, vec<N, bool>) -> vec<N, bool> */
    /* op |<T : ia_iu32>(T, T) -> T */
    /* op |<T : ia_iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ OverloadIndex(273),
  },
  {
    /* [8] */
    /* op &&(bool, bool) -> bool */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(461),
  },
  {
    /* [9] */
    /* op ||(bool, bool) -> bool */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(462),
  },
  {
    /* [10] */
    /* op ==<T : scalar>(T, T) -> bool */
    /* op ==<T : scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(416),
  },
  {
    /* [11] */
    /* op !=<T : scalar>(T, T) -> bool */
    /* op !=<T : scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(418),
  },
  {
    /* [12] */
    /* op <<T : fia_fiu32_f16>(T, T) -> bool */
    /* op <<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(420),
  },
  {
    /* [13] */
    /* op ><T : fia_fiu32_f16>(T, T) -> bool */
    /* op ><T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(422),
  },
  {
    /* [14] */
    /* op <=<T : fia_fiu32_f16>(T, T) -> bool */
    /* op <=<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(424),
  },
  {
    /* [15] */
    /* op >=<T : fia_fiu32_f16>(T, T) -> bool */
    /* op >=<T : fia_fiu32_f16, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(426),
  },
  {
    /* [16] */
    /* op <<<T : ia_iu32>(T, u32) -> T */
    /* op <<<T : ia_iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(428),
  },
  {
    /* [17] */
    /* op >><T : ia_iu32>(T, u32) -> T */
    /* op >><T : ia_iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ OverloadIndex(430),
  },
};
constexpr uint8_t kBinaryOperatorPlus = 0;
constexpr uint8_t kBinaryOperatorMinus = 1;
constexpr uint8_t kBinaryOperatorStar = 2;
constexpr uint8_t kBinaryOperatorDivide = 3;
constexpr uint8_t kBinaryOperatorModulo = 4;
constexpr uint8_t kBinaryOperatorXor = 5;
constexpr uint8_t kBinaryOperatorAnd = 6;
constexpr uint8_t kBinaryOperatorOr = 7;
constexpr uint8_t kBinaryOperatorLogicalAnd = 8;
constexpr uint8_t kBinaryOperatorLogicalOr = 9;
constexpr uint8_t kBinaryOperatorEqual = 10;
constexpr uint8_t kBinaryOperatorNotEqual = 11;
constexpr uint8_t kBinaryOperatorLessThan = 12;
constexpr uint8_t kBinaryOperatorGreaterThan = 13;
constexpr uint8_t kBinaryOperatorLessThanEqual = 14;
constexpr uint8_t kBinaryOperatorGreaterThanEqual = 15;
constexpr uint8_t kBinaryOperatorShiftLeft = 16;
constexpr uint8_t kBinaryOperatorShiftRight = 17;

constexpr IntrinsicInfo kConstructorsAndConverters[] = {
  {
    /* [0] */
    /* ctor i32() -> i32 */
    /* ctor i32(i32) -> i32 */
    /* conv i32<T : scalar_no_i32>(T) -> i32 */
    /* num overloads */ 3,
    /* overloads */ OverloadIndex(283),
  },
  {
    /* [1] */
    /* ctor u32() -> u32 */
    /* ctor u32(u32) -> u32 */
    /* conv u32<T : scalar_no_u32>(T) -> u32 */
    /* num overloads */ 3,
    /* overloads */ OverloadIndex(286),
  },
  {
    /* [2] */
    /* ctor f32() -> f32 */
    /* ctor f32(f32) -> f32 */
    /* conv f32<T : scalar_no_f32>(T) -> f32 */
    /* num overloads */ 3,
    /* overloads */ OverloadIndex(289),
  },
  {
    /* [3] */
    /* ctor f16() -> f16 */
    /* ctor f16(f16) -> f16 */
    /* conv f16<T : scalar_no_f16>(T) -> f16 */
    /* num overloads */ 3,
    /* overloads */ OverloadIndex(292),
  },
  {
    /* [4] */
    /* ctor bool() -> bool */
    /* ctor bool(bool) -> bool */
    /* conv bool<T : scalar_no_bool>(T) -> bool */
    /* num overloads */ 3,
    /* overloads */ OverloadIndex(295),
  },
  {
    /* [5] */
    /* ctor vec2() -> vec2<ia> */
    /* ctor vec2<T : concrete_scalar>() -> vec2<T> */
    /* ctor vec2<T : scalar>(vec2<T>) -> vec2<T> */
    /* ctor vec2<T : scalar>(T) -> vec2<T> */
    /* ctor vec2<T : scalar>(x: T, y: T) -> vec2<T> */
    /* conv vec2<T : f32, U : scalar_no_f32>(vec2<U>) -> vec2<f32> */
    /* conv vec2<T : f16, U : scalar_no_f16>(vec2<U>) -> vec2<f16> */
    /* conv vec2<T : i32, U : scalar_no_i32>(vec2<U>) -> vec2<i32> */
    /* conv vec2<T : u32, U : scalar_no_u32>(vec2<U>) -> vec2<u32> */
    /* conv vec2<T : bool, U : scalar_no_bool>(vec2<U>) -> vec2<bool> */
    /* num overloads */ 10,
    /* overloads */ OverloadIndex(139),
  },
  {
    /* [6] */
    /* ctor vec3() -> vec3<ia> */
    /* ctor vec3<T : concrete_scalar>() -> vec3<T> */
    /* ctor vec3<T : scalar>(vec3<T>) -> vec3<T> */
    /* ctor vec3<T : scalar>(T) -> vec3<T> */
    /* ctor vec3<T : scalar>(x: T, y: T, z: T) -> vec3<T> */
    /* ctor vec3<T : scalar>(xy: vec2<T>, z: T) -> vec3<T> */
    /* ctor vec3<T : scalar>(x: T, yz: vec2<T>) -> vec3<T> */
    /* conv vec3<T : f32, U : scalar_no_f32>(vec3<U>) -> vec3<f32> */
    /* conv vec3<T : f16, U : scalar_no_f16>(vec3<U>) -> vec3<f16> */
    /* conv vec3<T : i32, U : scalar_no_i32>(vec3<U>) -> vec3<i32> */
    /* conv vec3<T : u32, U : scalar_no_u32>(vec3<U>) -> vec3<u32> */
    /* conv vec3<T : bool, U : scalar_no_bool>(vec3<U>) -> vec3<bool> */
    /* num overloads */ 12,
    /* overloads */ OverloadIndex(117),
  },
  {
    /* [7] */
    /* ctor vec4() -> vec4<ia> */
    /* ctor vec4<T : concrete_scalar>() -> vec4<T> */
    /* ctor vec4<T : scalar>(vec4<T>) -> vec4<T> */
    /* ctor vec4<T : scalar>(T) -> vec4<T> */
    /* ctor vec4<T : scalar>(x: T, y: T, z: T, w: T) -> vec4<T> */
    /* ctor vec4<T : scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T> */
    /* ctor vec4<T : scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T> */
    /* ctor vec4<T : scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T> */
    /* ctor vec4<T : scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T> */
    /* ctor vec4<T : scalar>(xyz: vec3<T>, w: T) -> vec4<T> */
    /* ctor vec4<T : scalar>(x: T, zyw: vec3<T>) -> vec4<T> */
    /* conv vec4<T : f32, U : scalar_no_f32>(vec4<U>) -> vec4<f32> */
    /* conv vec4<T : f16, U : scalar_no_f16>(vec4<U>) -> vec4<f16> */
    /* conv vec4<T : i32, U : scalar_no_i32>(vec4<U>) -> vec4<i32> */
    /* conv vec4<T : u32, U : scalar_no_u32>(vec4<U>) -> vec4<u32> */
    /* conv vec4<T : bool, U : scalar_no_bool>(vec4<U>) -> vec4<bool> */
    /* num overloads */ 16,
    /* overloads */ OverloadIndex(48),
  },
  {
    /* [8] */
    /* ctor mat2x2<T : f32_f16>() -> mat2x2<T> */
    /* ctor mat2x2<T : f32_f16>(mat2x2<T>) -> mat2x2<T> */
    /* ctor mat2x2<T : fa_f32_f16>(T, T, T, T) -> mat2x2<T> */
    /* ctor mat2x2<T : fa_f32_f16>(vec2<T>, vec2<T>) -> mat2x2<T> */
    /* conv mat2x2<T : f16>(mat2x2<f32>) -> mat2x2<f16> */
    /* conv mat2x2<T : f32>(mat2x2<f16>) -> mat2x2<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(192),
  },
  {
    /* [9] */
    /* ctor mat2x3<T : f32_f16>() -> mat2x3<T> */
    /* ctor mat2x3<T : f32_f16>(mat2x3<T>) -> mat2x3<T> */
    /* ctor mat2x3<T : fa_f32_f16>(T, T, T, T, T, T) -> mat2x3<T> */
    /* ctor mat2x3<T : fa_f32_f16>(vec3<T>, vec3<T>) -> mat2x3<T> */
    /* conv mat2x3<T : f16>(mat2x3<f32>) -> mat2x3<f16> */
    /* conv mat2x3<T : f32>(mat2x3<f16>) -> mat2x3<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(198),
  },
  {
    /* [10] */
    /* ctor mat2x4<T : f32_f16>() -> mat2x4<T> */
    /* ctor mat2x4<T : f32_f16>(mat2x4<T>) -> mat2x4<T> */
    /* ctor mat2x4<T : fa_f32_f16>(T, T, T, T, T, T, T, T) -> mat2x4<T> */
    /* ctor mat2x4<T : fa_f32_f16>(vec4<T>, vec4<T>) -> mat2x4<T> */
    /* conv mat2x4<T : f16>(mat2x4<f32>) -> mat2x4<f16> */
    /* conv mat2x4<T : f32>(mat2x4<f16>) -> mat2x4<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(204),
  },
  {
    /* [11] */
    /* ctor mat3x2<T : f32_f16>() -> mat3x2<T> */
    /* ctor mat3x2<T : f32_f16>(mat3x2<T>) -> mat3x2<T> */
    /* ctor mat3x2<T : fa_f32_f16>(T, T, T, T, T, T) -> mat3x2<T> */
    /* ctor mat3x2<T : fa_f32_f16>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T> */
    /* conv mat3x2<T : f16>(mat3x2<f32>) -> mat3x2<f16> */
    /* conv mat3x2<T : f32>(mat3x2<f16>) -> mat3x2<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(210),
  },
  {
    /* [12] */
    /* ctor mat3x3<T : f32_f16>() -> mat3x3<T> */
    /* ctor mat3x3<T : f32_f16>(mat3x3<T>) -> mat3x3<T> */
    /* ctor mat3x3<T : fa_f32_f16>(T, T, T, T, T, T, T, T, T) -> mat3x3<T> */
    /* ctor mat3x3<T : fa_f32_f16>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T> */
    /* conv mat3x3<T : f16>(mat3x3<f32>) -> mat3x3<f16> */
    /* conv mat3x3<T : f32>(mat3x3<f16>) -> mat3x3<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(216),
  },
  {
    /* [13] */
    /* ctor mat3x4<T : f32_f16>() -> mat3x4<T> */
    /* ctor mat3x4<T : f32_f16>(mat3x4<T>) -> mat3x4<T> */
    /* ctor mat3x4<T : fa_f32_f16>(T, T, T, T, T, T, T, T, T, T, T, T) -> mat3x4<T> */
    /* ctor mat3x4<T : fa_f32_f16>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T> */
    /* conv mat3x4<T : f16>(mat3x4<f32>) -> mat3x4<f16> */
    /* conv mat3x4<T : f32>(mat3x4<f16>) -> mat3x4<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(222),
  },
  {
    /* [14] */
    /* ctor mat4x2<T : f32_f16>() -> mat4x2<T> */
    /* ctor mat4x2<T : f32_f16>(mat4x2<T>) -> mat4x2<T> */
    /* ctor mat4x2<T : fa_f32_f16>(T, T, T, T, T, T, T, T) -> mat4x2<T> */
    /* ctor mat4x2<T : fa_f32_f16>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T> */
    /* conv mat4x2<T : f16>(mat4x2<f32>) -> mat4x2<f16> */
    /* conv mat4x2<T : f32>(mat4x2<f16>) -> mat4x2<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(228),
  },
  {
    /* [15] */
    /* ctor mat4x3<T : f32_f16>() -> mat4x3<T> */
    /* ctor mat4x3<T : f32_f16>(mat4x3<T>) -> mat4x3<T> */
    /* ctor mat4x3<T : fa_f32_f16>(T, T, T, T, T, T, T, T, T, T, T, T) -> mat4x3<T> */
    /* ctor mat4x3<T : fa_f32_f16>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T> */
    /* conv mat4x3<T : f16>(mat4x3<f32>) -> mat4x3<f16> */
    /* conv mat4x3<T : f32>(mat4x3<f16>) -> mat4x3<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(234),
  },
  {
    /* [16] */
    /* ctor mat4x4<T : f32_f16>() -> mat4x4<T> */
    /* ctor mat4x4<T : f32_f16>(mat4x4<T>) -> mat4x4<T> */
    /* ctor mat4x4<T : fa_f32_f16>(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) -> mat4x4<T> */
    /* ctor mat4x4<T : fa_f32_f16>(vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T> */
    /* conv mat4x4<T : f16>(mat4x4<f32>) -> mat4x4<f16> */
    /* conv mat4x4<T : f32>(mat4x4<f16>) -> mat4x4<f32> */
    /* num overloads */ 6,
    /* overloads */ OverloadIndex(240),
  },
  {
    /* [17] */
    /* conv packedVec3<T : concrete_scalar>(vec3<T>) -> packedVec3<T> */
    /* num overloads */ 1,
    /* overloads */ OverloadIndex(463),
  },
};

// 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 */ kConstEvalFunctions,
    /* ctor_conv */ kConstructorsAndConverters,
    /* builtins */ kBuiltins,
    /* binary '+' */ kBinaryOperators[kBinaryOperatorPlus],
    /* binary '-' */ kBinaryOperators[kBinaryOperatorMinus],
    /* binary '*' */ kBinaryOperators[kBinaryOperatorStar],
    /* binary '/' */ kBinaryOperators[kBinaryOperatorDivide],
    /* binary '%' */ kBinaryOperators[kBinaryOperatorModulo],
    /* binary '^' */ kBinaryOperators[kBinaryOperatorXor],
    /* binary '&' */ kBinaryOperators[kBinaryOperatorAnd],
    /* binary '|' */ kBinaryOperators[kBinaryOperatorOr],
    /* binary '&&' */ kBinaryOperators[kBinaryOperatorLogicalAnd],
    /* binary '||' */ kBinaryOperators[kBinaryOperatorLogicalOr],
    /* binary '==' */ kBinaryOperators[kBinaryOperatorEqual],
    /* binary '!=' */ kBinaryOperators[kBinaryOperatorNotEqual],
    /* binary '<' */ kBinaryOperators[kBinaryOperatorLessThan],
    /* binary '>' */ kBinaryOperators[kBinaryOperatorGreaterThan],
    /* binary '<=' */ kBinaryOperators[kBinaryOperatorLessThanEqual],
    /* binary '>=' */ kBinaryOperators[kBinaryOperatorGreaterThanEqual],
    /* binary '<<' */ kBinaryOperators[kBinaryOperatorShiftLeft],
    /* binary '>>' */ kBinaryOperators[kBinaryOperatorShiftRight],
    /* unary '!' */ kUnaryOperators[kUnaryOperatorNot],
    /* unary '~' */ kUnaryOperators[kUnaryOperatorComplement],
    /* unary '-' */ kUnaryOperators[kUnaryOperatorMinus],
};

}  // namespace tint::core::intrinsic::data