// Copyright 2021 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/intrinsic-gen
// using the template:
//   src/tint/resolver/intrinsic_table.inl.tmpl
// and the intrinsic defintion file:
//   src/tint/intrinsics.def
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////

// clang-format off

/// TypeMatcher for 'type bool'
/// @see src/tint/intrinsics.def:68:6
class Bool : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Bool::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_bool(ty)) {
    return nullptr;
  }
  return build_bool(state);
}

std::string Bool::String(MatchState&) const {
  return "bool";
}

/// TypeMatcher for 'type f32'
/// @see src/tint/intrinsics.def:69:6
class F32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* F32::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_f32(ty)) {
    return nullptr;
  }
  return build_f32(state);
}

std::string F32::String(MatchState&) const {
  return "f32";
}

/// TypeMatcher for 'type i32'
/// @see src/tint/intrinsics.def:70:6
class I32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* I32::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_i32(ty)) {
    return nullptr;
  }
  return build_i32(state);
}

std::string I32::String(MatchState&) const {
  return "i32";
}

/// TypeMatcher for 'type u32'
/// @see src/tint/intrinsics.def:71:6
class U32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* U32::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_u32(ty)) {
    return nullptr;
  }
  return build_u32(state);
}

std::string U32::String(MatchState&) const {
  return "u32";
}

/// TypeMatcher for 'type vec2'
/// @see src/tint/intrinsics.def:72:6
class Vec2 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Vec2::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_vec2(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_vec2(state, T);
}

std::string Vec2::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "vec2<" + T + ">";
}

/// TypeMatcher for 'type vec3'
/// @see src/tint/intrinsics.def:73:6
class Vec3 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Vec3::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_vec3(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_vec3(state, T);
}

std::string Vec3::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "vec3<" + T + ">";
}

/// TypeMatcher for 'type vec4'
/// @see src/tint/intrinsics.def:74:6
class Vec4 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Vec4::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_vec4(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_vec4(state, T);
}

std::string Vec4::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "vec4<" + T + ">";
}

/// TypeMatcher for 'type mat2x2'
/// @see src/tint/intrinsics.def:75:6
class Mat2X2 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat2X2::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat2x2(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat2x2(state, T);
}

std::string Mat2X2::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat2x2<" + T + ">";
}

/// TypeMatcher for 'type mat2x3'
/// @see src/tint/intrinsics.def:76:6
class Mat2X3 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat2X3::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat2x3(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat2x3(state, T);
}

std::string Mat2X3::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat2x3<" + T + ">";
}

/// TypeMatcher for 'type mat2x4'
/// @see src/tint/intrinsics.def:77:6
class Mat2X4 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat2X4::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat2x4(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat2x4(state, T);
}

std::string Mat2X4::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat2x4<" + T + ">";
}

/// TypeMatcher for 'type mat3x2'
/// @see src/tint/intrinsics.def:78:6
class Mat3X2 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat3X2::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat3x2(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat3x2(state, T);
}

std::string Mat3X2::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat3x2<" + T + ">";
}

/// TypeMatcher for 'type mat3x3'
/// @see src/tint/intrinsics.def:79:6
class Mat3X3 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat3X3::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat3x3(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat3x3(state, T);
}

std::string Mat3X3::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat3x3<" + T + ">";
}

/// TypeMatcher for 'type mat3x4'
/// @see src/tint/intrinsics.def:80:6
class Mat3X4 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat3X4::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat3x4(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat3x4(state, T);
}

std::string Mat3X4::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat3x4<" + T + ">";
}

/// TypeMatcher for 'type mat4x2'
/// @see src/tint/intrinsics.def:81:6
class Mat4X2 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat4X2::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat4x2(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat4x2(state, T);
}

std::string Mat4X2::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat4x2<" + T + ">";
}

/// TypeMatcher for 'type mat4x3'
/// @see src/tint/intrinsics.def:82:6
class Mat4X3 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat4X3::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat4x3(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat4x3(state, T);
}

std::string Mat4X3::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat4x3<" + T + ">";
}

/// TypeMatcher for 'type mat4x4'
/// @see src/tint/intrinsics.def:83:6
class Mat4X4 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat4X4::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_mat4x4(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_mat4x4(state, T);
}

std::string Mat4X4::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "mat4x4<" + T + ">";
}

/// TypeMatcher for 'type vec'
/// @see src/tint/intrinsics.def:84:37
class Vec : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Vec::Match(MatchState& state, const sem::Type* ty) const {
  Number N = Number::invalid;
  const sem::Type* T = nullptr;
  if (!match_vec(ty, N, T)) {
    return nullptr;
  }
  N = state.Num(N);
  if (!N.IsValid()) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_vec(state, N, T);
}

std::string Vec::String(MatchState& state) const {
  const std::string N = state.NumName();
  const std::string T = state.TypeName();
  std::stringstream ss;
  ss << "vec" << N << "<" << T << ">";
  return ss.str();
}

/// TypeMatcher for 'type mat'
/// @see src/tint/intrinsics.def:85:37
class Mat : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Mat::Match(MatchState& state, const sem::Type* ty) const {
  Number N = Number::invalid;
  Number M = Number::invalid;
  const sem::Type* T = nullptr;
  if (!match_mat(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 build_mat(state, N, M, T);
}

std::string Mat::String(MatchState& state) const {
  const std::string N = state.NumName();
  const std::string M = state.NumName();
  const std::string T = state.TypeName();
  std::stringstream ss;
  ss << "mat" << N << "x" << M << "<" << T << ">";
  return ss.str();
}

/// TypeMatcher for 'type ptr'
/// @see src/tint/intrinsics.def:86:6
class Ptr : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Ptr::Match(MatchState& state, const sem::Type* ty) const {
  Number S = Number::invalid;
  const sem::Type* T = nullptr;
  Number A = Number::invalid;
  if (!match_ptr(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 build_ptr(state, S, T, A);
}

std::string Ptr::String(MatchState& state) const {
  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'
/// @see src/tint/intrinsics.def:87:6
class Atomic : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Atomic::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_atomic(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_atomic(state, T);
}

std::string Atomic::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "atomic<" + T + ">";
}

/// TypeMatcher for 'type array'
/// @see src/tint/intrinsics.def:88:6
class Array : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Array::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_array(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_array(state, T);
}

std::string Array::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "array<" + T + ">";
}

/// TypeMatcher for 'type sampler'
/// @see src/tint/intrinsics.def:89:6
class Sampler : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Sampler::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_sampler(ty)) {
    return nullptr;
  }
  return build_sampler(state);
}

std::string Sampler::String(MatchState&) const {
  return "sampler";
}

/// TypeMatcher for 'type sampler_comparison'
/// @see src/tint/intrinsics.def:90:6
class SamplerComparison : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* SamplerComparison::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_sampler_comparison(ty)) {
    return nullptr;
  }
  return build_sampler_comparison(state);
}

std::string SamplerComparison::String(MatchState&) const {
  return "sampler_comparison";
}

/// TypeMatcher for 'type texture_1d'
/// @see src/tint/intrinsics.def:91:6
class Texture1D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Texture1D::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_texture_1d(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_texture_1d(state, T);
}

std::string Texture1D::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "texture_1d<" + T + ">";
}

/// TypeMatcher for 'type texture_2d'
/// @see src/tint/intrinsics.def:92:6
class Texture2D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Texture2D::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_texture_2d(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_texture_2d(state, T);
}

std::string Texture2D::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "texture_2d<" + T + ">";
}

/// TypeMatcher for 'type texture_2d_array'
/// @see src/tint/intrinsics.def:93:6
class Texture2DArray : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Texture2DArray::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_texture_2d_array(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_texture_2d_array(state, T);
}

std::string Texture2DArray::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "texture_2d_array<" + T + ">";
}

/// TypeMatcher for 'type texture_3d'
/// @see src/tint/intrinsics.def:94:6
class Texture3D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Texture3D::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_texture_3d(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_texture_3d(state, T);
}

std::string Texture3D::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "texture_3d<" + T + ">";
}

/// TypeMatcher for 'type texture_cube'
/// @see src/tint/intrinsics.def:95:6
class TextureCube : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureCube::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_texture_cube(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_texture_cube(state, T);
}

std::string TextureCube::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "texture_cube<" + T + ">";
}

/// TypeMatcher for 'type texture_cube_array'
/// @see src/tint/intrinsics.def:96:6
class TextureCubeArray : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureCubeArray::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_texture_cube_array(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_texture_cube_array(state, T);
}

std::string TextureCubeArray::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "texture_cube_array<" + T + ">";
}

/// TypeMatcher for 'type texture_multisampled_2d'
/// @see src/tint/intrinsics.def:97:6
class TextureMultisampled2D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureMultisampled2D::Match(MatchState& state, const sem::Type* ty) const {
  const sem::Type* T = nullptr;
  if (!match_texture_multisampled_2d(ty, T)) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  return build_texture_multisampled_2d(state, T);
}

std::string TextureMultisampled2D::String(MatchState& state) const {
  const std::string T = state.TypeName();
  return "texture_multisampled_2d<" + T + ">";
}

/// TypeMatcher for 'type texture_depth_2d'
/// @see src/tint/intrinsics.def:98:6
class TextureDepth2D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureDepth2D::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_texture_depth_2d(ty)) {
    return nullptr;
  }
  return build_texture_depth_2d(state);
}

std::string TextureDepth2D::String(MatchState&) const {
  return "texture_depth_2d";
}

/// TypeMatcher for 'type texture_depth_2d_array'
/// @see src/tint/intrinsics.def:99:6
class TextureDepth2DArray : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureDepth2DArray::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_texture_depth_2d_array(ty)) {
    return nullptr;
  }
  return build_texture_depth_2d_array(state);
}

std::string TextureDepth2DArray::String(MatchState&) const {
  return "texture_depth_2d_array";
}

/// TypeMatcher for 'type texture_depth_cube'
/// @see src/tint/intrinsics.def:100:6
class TextureDepthCube : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureDepthCube::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_texture_depth_cube(ty)) {
    return nullptr;
  }
  return build_texture_depth_cube(state);
}

std::string TextureDepthCube::String(MatchState&) const {
  return "texture_depth_cube";
}

/// TypeMatcher for 'type texture_depth_cube_array'
/// @see src/tint/intrinsics.def:101:6
class TextureDepthCubeArray : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureDepthCubeArray::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_texture_depth_cube_array(ty)) {
    return nullptr;
  }
  return build_texture_depth_cube_array(state);
}

std::string TextureDepthCubeArray::String(MatchState&) const {
  return "texture_depth_cube_array";
}

/// TypeMatcher for 'type texture_depth_multisampled_2d'
/// @see src/tint/intrinsics.def:102:6
class TextureDepthMultisampled2D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureDepthMultisampled2D::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_texture_depth_multisampled_2d(ty)) {
    return nullptr;
  }
  return build_texture_depth_multisampled_2d(state);
}

std::string TextureDepthMultisampled2D::String(MatchState&) const {
  return "texture_depth_multisampled_2d";
}

/// TypeMatcher for 'type texture_storage_1d'
/// @see src/tint/intrinsics.def:103:6
class TextureStorage1D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureStorage1D::Match(MatchState& state, const sem::Type* ty) const {
  Number F = Number::invalid;
  Number A = Number::invalid;
  if (!match_texture_storage_1d(ty, F, A)) {
    return nullptr;
  }
  F = state.Num(F);
  if (!F.IsValid()) {
    return nullptr;
  }
  A = state.Num(A);
  if (!A.IsValid()) {
    return nullptr;
  }
  return build_texture_storage_1d(state, F, A);
}

std::string TextureStorage1D::String(MatchState& state) const {
  const std::string F = state.NumName();
  const std::string A = state.NumName();
  return "texture_storage_1d<" + F + ", " + A + ">";
}

/// TypeMatcher for 'type texture_storage_2d'
/// @see src/tint/intrinsics.def:104:6
class TextureStorage2D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureStorage2D::Match(MatchState& state, const sem::Type* ty) const {
  Number F = Number::invalid;
  Number A = Number::invalid;
  if (!match_texture_storage_2d(ty, F, A)) {
    return nullptr;
  }
  F = state.Num(F);
  if (!F.IsValid()) {
    return nullptr;
  }
  A = state.Num(A);
  if (!A.IsValid()) {
    return nullptr;
  }
  return build_texture_storage_2d(state, F, A);
}

std::string TextureStorage2D::String(MatchState& state) const {
  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'
/// @see src/tint/intrinsics.def:105:6
class TextureStorage2DArray : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureStorage2DArray::Match(MatchState& state, const sem::Type* ty) const {
  Number F = Number::invalid;
  Number A = Number::invalid;
  if (!match_texture_storage_2d_array(ty, F, A)) {
    return nullptr;
  }
  F = state.Num(F);
  if (!F.IsValid()) {
    return nullptr;
  }
  A = state.Num(A);
  if (!A.IsValid()) {
    return nullptr;
  }
  return build_texture_storage_2d_array(state, F, A);
}

std::string TextureStorage2DArray::String(MatchState& state) const {
  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'
/// @see src/tint/intrinsics.def:106:6
class TextureStorage3D : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureStorage3D::Match(MatchState& state, const sem::Type* ty) const {
  Number F = Number::invalid;
  Number A = Number::invalid;
  if (!match_texture_storage_3d(ty, F, A)) {
    return nullptr;
  }
  F = state.Num(F);
  if (!F.IsValid()) {
    return nullptr;
  }
  A = state.Num(A);
  if (!A.IsValid()) {
    return nullptr;
  }
  return build_texture_storage_3d(state, F, A);
}

std::string TextureStorage3D::String(MatchState& state) const {
  const std::string F = state.NumName();
  const std::string A = state.NumName();
  return "texture_storage_3d<" + F + ", " + A + ">";
}

/// TypeMatcher for 'type texture_external'
/// @see src/tint/intrinsics.def:107:6
class TextureExternal : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* TextureExternal::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_texture_external(ty)) {
    return nullptr;
  }
  return build_texture_external(state);
}

std::string TextureExternal::String(MatchState&) const {
  return "texture_external";
}

/// TypeMatcher for 'type __modf_result'
/// @see src/tint/intrinsics.def:109:6
class ModfResult : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* ModfResult::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_modf_result(ty)) {
    return nullptr;
  }
  return build_modf_result(state);
}

std::string ModfResult::String(MatchState&) const {
  return "__modf_result";
}

/// TypeMatcher for 'type __modf_result_vec'
/// @see src/tint/intrinsics.def:110:42
class ModfResultVec : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* ModfResultVec::Match(MatchState& state, const sem::Type* ty) const {
  Number N = Number::invalid;
  if (!match_modf_result_vec(ty, N)) {
    return nullptr;
  }
  N = state.Num(N);
  if (!N.IsValid()) {
    return nullptr;
  }
  return build_modf_result_vec(state, N);
}

std::string ModfResultVec::String(MatchState& state) const {
  const std::string N = state.NumName();
  std::stringstream ss;
  ss << "__modf_result_vec" << N;
  return ss.str();
}

/// TypeMatcher for 'type __frexp_result'
/// @see src/tint/intrinsics.def:111:6
class FrexpResult : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* FrexpResult::Match(MatchState& state, const sem::Type* ty) const {
  if (!match_frexp_result(ty)) {
    return nullptr;
  }
  return build_frexp_result(state);
}

std::string FrexpResult::String(MatchState&) const {
  return "__frexp_result";
}

/// TypeMatcher for 'type __frexp_result_vec'
/// @see src/tint/intrinsics.def:112:43
class FrexpResultVec : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* FrexpResultVec::Match(MatchState& state, const sem::Type* ty) const {
  Number N = Number::invalid;
  if (!match_frexp_result_vec(ty, N)) {
    return nullptr;
  }
  N = state.Num(N);
  if (!N.IsValid()) {
    return nullptr;
  }
  return build_frexp_result_vec(state, N);
}

std::string FrexpResultVec::String(MatchState& state) const {
  const std::string N = state.NumName();
  std::stringstream ss;
  ss << "__frexp_result_vec" << N;
  return ss.str();
}

/// TypeMatcher for 'match fiu32'
/// @see src/tint/intrinsics.def:120:7
class Fiu32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Fiu32::Match(MatchState& state, const sem::Type* ty) const {
  if (match_f32(ty)) {
    return build_f32(state);
  }
  if (match_i32(ty)) {
    return build_i32(state);
  }
  if (match_u32(ty)) {
    return build_u32(state);
  }
  return nullptr;
}

std::string Fiu32::String(MatchState&) const {
  return "f32, i32 or u32";
}

/// TypeMatcher for 'match fi32'
/// @see src/tint/intrinsics.def:121:7
class Fi32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Fi32::Match(MatchState& state, const sem::Type* ty) const {
  if (match_f32(ty)) {
    return build_f32(state);
  }
  if (match_i32(ty)) {
    return build_i32(state);
  }
  return nullptr;
}

std::string Fi32::String(MatchState&) const {
  return "f32 or i32";
}

/// TypeMatcher for 'match iu32'
/// @see src/tint/intrinsics.def:122:7
class Iu32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Iu32::Match(MatchState& state, const sem::Type* ty) const {
  if (match_i32(ty)) {
    return build_i32(state);
  }
  if (match_u32(ty)) {
    return build_u32(state);
  }
  return nullptr;
}

std::string Iu32::String(MatchState&) const {
  return "i32 or u32";
}

/// TypeMatcher for 'match scalar'
/// @see src/tint/intrinsics.def:123:7
class Scalar : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* Scalar::Match(MatchState& state, const sem::Type* ty) const {
  if (match_f32(ty)) {
    return build_f32(state);
  }
  if (match_i32(ty)) {
    return build_i32(state);
  }
  if (match_u32(ty)) {
    return build_u32(state);
  }
  if (match_bool(ty)) {
    return build_bool(state);
  }
  return nullptr;
}

std::string Scalar::String(MatchState&) const {
  return "f32, i32, u32 or bool";
}

/// TypeMatcher for 'match scalar_no_f32'
/// @see src/tint/intrinsics.def:124:7
class ScalarNoF32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* ScalarNoF32::Match(MatchState& state, const sem::Type* ty) const {
  if (match_i32(ty)) {
    return build_i32(state);
  }
  if (match_u32(ty)) {
    return build_u32(state);
  }
  if (match_bool(ty)) {
    return build_bool(state);
  }
  return nullptr;
}

std::string ScalarNoF32::String(MatchState&) const {
  return "i32, u32 or bool";
}

/// TypeMatcher for 'match scalar_no_i32'
/// @see src/tint/intrinsics.def:125:7
class ScalarNoI32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* ScalarNoI32::Match(MatchState& state, const sem::Type* ty) const {
  if (match_f32(ty)) {
    return build_f32(state);
  }
  if (match_u32(ty)) {
    return build_u32(state);
  }
  if (match_bool(ty)) {
    return build_bool(state);
  }
  return nullptr;
}

std::string ScalarNoI32::String(MatchState&) const {
  return "f32, u32 or bool";
}

/// TypeMatcher for 'match scalar_no_u32'
/// @see src/tint/intrinsics.def:126:7
class ScalarNoU32 : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* ScalarNoU32::Match(MatchState& state, const sem::Type* ty) const {
  if (match_f32(ty)) {
    return build_f32(state);
  }
  if (match_i32(ty)) {
    return build_i32(state);
  }
  if (match_bool(ty)) {
    return build_bool(state);
  }
  return nullptr;
}

std::string ScalarNoU32::String(MatchState&) const {
  return "f32, i32 or bool";
}

/// TypeMatcher for 'match scalar_no_bool'
/// @see src/tint/intrinsics.def:127:7
class ScalarNoBool : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules, and returns the
  /// expected, canonicalized type on success.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

const sem::Type* ScalarNoBool::Match(MatchState& state, const sem::Type* ty) const {
  if (match_f32(ty)) {
    return build_f32(state);
  }
  if (match_i32(ty)) {
    return build_i32(state);
  }
  if (match_u32(ty)) {
    return build_u32(state);
  }
  return nullptr;
}

std::string ScalarNoBool::String(MatchState&) const {
  return "f32, i32 or u32";
}

/// EnumMatcher for 'match f32_texel_format'
/// @see src/tint/intrinsics.def:138:7
class F32TexelFormat : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number F32TexelFormat::Match(MatchState&, Number number) const {
  switch (static_cast<TexelFormat>(number.Value())) {
    case TexelFormat::kRgba8Unorm:
    case TexelFormat::kRgba8Snorm:
    case TexelFormat::kRgba16Float:
    case TexelFormat::kR32Float:
    case TexelFormat::kRg32Float:
    case TexelFormat::kRgba32Float:
      return number;
    default:
      return Number::invalid;
  }
}

std::string F32TexelFormat::String(MatchState&) const {
  return "rgba8unorm, rgba8snorm, rgba16float, r32float, rg32float or rgba32float";
}

/// EnumMatcher for 'match i32_texel_format'
/// @see src/tint/intrinsics.def:140:7
class I32TexelFormat : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number I32TexelFormat::Match(MatchState&, Number number) const {
  switch (static_cast<TexelFormat>(number.Value())) {
    case TexelFormat::kRgba8Sint:
    case TexelFormat::kRgba16Sint:
    case TexelFormat::kR32Sint:
    case TexelFormat::kRg32Sint:
    case TexelFormat::kRgba32Sint:
      return number;
    default:
      return Number::invalid;
  }
}

std::string I32TexelFormat::String(MatchState&) const {
  return "rgba8sint, rgba16sint, r32sint, rg32sint or rgba32sint";
}

/// EnumMatcher for 'match u32_texel_format'
/// @see src/tint/intrinsics.def:142:7
class U32TexelFormat : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number U32TexelFormat::Match(MatchState&, Number number) const {
  switch (static_cast<TexelFormat>(number.Value())) {
    case TexelFormat::kRgba8Uint:
    case TexelFormat::kRgba16Uint:
    case TexelFormat::kR32Uint:
    case TexelFormat::kRg32Uint:
    case TexelFormat::kRgba32Uint:
      return number;
    default:
      return Number::invalid;
  }
}

std::string U32TexelFormat::String(MatchState&) const {
  return "rgba8uint, rgba16uint, r32uint, rg32uint or rgba32uint";
}

/// EnumMatcher for 'match write_only'
/// @see src/tint/intrinsics.def:145:7
class WriteOnly : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number WriteOnly::Match(MatchState&, Number number) const {
  if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kWrite)) {
    return Number(static_cast<uint32_t>(Access::kWrite));
  }
  return Number::invalid;
}

std::string WriteOnly::String(MatchState&) const {
  return "write";
}

/// EnumMatcher for 'match function_private_workgroup'
/// @see src/tint/intrinsics.def:147:7
class FunctionPrivateWorkgroup : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number FunctionPrivateWorkgroup::Match(MatchState&, Number number) const {
  switch (static_cast<StorageClass>(number.Value())) {
    case StorageClass::kFunction:
    case StorageClass::kPrivate:
    case StorageClass::kWorkgroup:
      return number;
    default:
      return Number::invalid;
  }
}

std::string FunctionPrivateWorkgroup::String(MatchState&) const {
  return "function, private or workgroup";
}

/// EnumMatcher for 'match workgroup_or_storage'
/// @see src/tint/intrinsics.def:148:7
class WorkgroupOrStorage : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number WorkgroupOrStorage::Match(MatchState&, Number number) const {
  switch (static_cast<StorageClass>(number.Value())) {
    case StorageClass::kWorkgroup:
    case StorageClass::kStorage:
      return number;
    default:
      return Number::invalid;
  }
}

std::string WorkgroupOrStorage::String(MatchState&) const {
  return "workgroup or storage";
}

/// EnumMatcher for 'match storage'
class Storage : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number Storage::Match(MatchState&, Number number) const {
  if (number.IsAny() || number.Value() == static_cast<uint32_t>(StorageClass::kStorage)) {
    return Number(static_cast<uint32_t>(StorageClass::kStorage));
  }
  return Number::invalid;
}

std::string Storage::String(MatchState&) const {
  return "storage";
}

/// EnumMatcher for 'match write'
class Write : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number Write::Match(MatchState&, Number number) const {
  if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kWrite)) {
    return Number(static_cast<uint32_t>(Access::kWrite));
  }
  return Number::invalid;
}

std::string Write::String(MatchState&) const {
  return "write";
}

/// EnumMatcher for 'match read_write'
class ReadWrite : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

Number ReadWrite::Match(MatchState&, Number number) const {
  if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kReadWrite)) {
    return Number(static_cast<uint32_t>(Access::kReadWrite));
  }
  return Number::invalid;
}

std::string ReadWrite::String(MatchState&) const {
  return "read_write";
}

/// Matchers holds type and number matchers
class Matchers {
 private:
  OpenTypeMatcher open_type_0_{0};
  OpenTypeMatcher open_type_1_{1};
  OpenNumberMatcher open_number_0_{0};
  OpenNumberMatcher open_number_1_{1};
  OpenNumberMatcher open_number_2_{2};
  Bool Bool_;
  F32 F32_;
  I32 I32_;
  U32 U32_;
  Vec2 Vec2_;
  Vec3 Vec3_;
  Vec4 Vec4_;
  Mat2X2 Mat2X2_;
  Mat2X3 Mat2X3_;
  Mat2X4 Mat2X4_;
  Mat3X2 Mat3X2_;
  Mat3X3 Mat3X3_;
  Mat3X4 Mat3X4_;
  Mat4X2 Mat4X2_;
  Mat4X3 Mat4X3_;
  Mat4X4 Mat4X4_;
  Vec Vec_;
  Mat Mat_;
  Ptr Ptr_;
  Atomic Atomic_;
  Array Array_;
  Sampler Sampler_;
  SamplerComparison SamplerComparison_;
  Texture1D Texture1D_;
  Texture2D Texture2D_;
  Texture2DArray Texture2DArray_;
  Texture3D Texture3D_;
  TextureCube TextureCube_;
  TextureCubeArray TextureCubeArray_;
  TextureMultisampled2D TextureMultisampled2D_;
  TextureDepth2D TextureDepth2D_;
  TextureDepth2DArray TextureDepth2DArray_;
  TextureDepthCube TextureDepthCube_;
  TextureDepthCubeArray TextureDepthCubeArray_;
  TextureDepthMultisampled2D TextureDepthMultisampled2D_;
  TextureStorage1D TextureStorage1D_;
  TextureStorage2D TextureStorage2D_;
  TextureStorage2DArray TextureStorage2DArray_;
  TextureStorage3D TextureStorage3D_;
  TextureExternal TextureExternal_;
  ModfResult ModfResult_;
  ModfResultVec ModfResultVec_;
  FrexpResult FrexpResult_;
  FrexpResultVec FrexpResultVec_;
  Fiu32 Fiu32_;
  Fi32 Fi32_;
  Iu32 Iu32_;
  Scalar Scalar_;
  ScalarNoF32 ScalarNoF32_;
  ScalarNoI32 ScalarNoI32_;
  ScalarNoU32 ScalarNoU32_;
  ScalarNoBool ScalarNoBool_;
  F32TexelFormat F32TexelFormat_;
  I32TexelFormat I32TexelFormat_;
  U32TexelFormat U32TexelFormat_;
  WriteOnly WriteOnly_;
  FunctionPrivateWorkgroup FunctionPrivateWorkgroup_;
  WorkgroupOrStorage WorkgroupOrStorage_;
  Storage Storage_;
  Write Write_;
  ReadWrite ReadWrite_;

 public:
  /// Constructor
  Matchers();
  /// Destructor
  ~Matchers();

  /// The open-types, types, and type matchers
  TypeMatcher const* const type[54] = {
    /* [0] */ &open_type_0_,
    /* [1] */ &open_type_1_,
    /* [2] */ &Bool_,
    /* [3] */ &F32_,
    /* [4] */ &I32_,
    /* [5] */ &U32_,
    /* [6] */ &Vec2_,
    /* [7] */ &Vec3_,
    /* [8] */ &Vec4_,
    /* [9] */ &Mat2X2_,
    /* [10] */ &Mat2X3_,
    /* [11] */ &Mat2X4_,
    /* [12] */ &Mat3X2_,
    /* [13] */ &Mat3X3_,
    /* [14] */ &Mat3X4_,
    /* [15] */ &Mat4X2_,
    /* [16] */ &Mat4X3_,
    /* [17] */ &Mat4X4_,
    /* [18] */ &Vec_,
    /* [19] */ &Mat_,
    /* [20] */ &Ptr_,
    /* [21] */ &Atomic_,
    /* [22] */ &Array_,
    /* [23] */ &Sampler_,
    /* [24] */ &SamplerComparison_,
    /* [25] */ &Texture1D_,
    /* [26] */ &Texture2D_,
    /* [27] */ &Texture2DArray_,
    /* [28] */ &Texture3D_,
    /* [29] */ &TextureCube_,
    /* [30] */ &TextureCubeArray_,
    /* [31] */ &TextureMultisampled2D_,
    /* [32] */ &TextureDepth2D_,
    /* [33] */ &TextureDepth2DArray_,
    /* [34] */ &TextureDepthCube_,
    /* [35] */ &TextureDepthCubeArray_,
    /* [36] */ &TextureDepthMultisampled2D_,
    /* [37] */ &TextureStorage1D_,
    /* [38] */ &TextureStorage2D_,
    /* [39] */ &TextureStorage2DArray_,
    /* [40] */ &TextureStorage3D_,
    /* [41] */ &TextureExternal_,
    /* [42] */ &ModfResult_,
    /* [43] */ &ModfResultVec_,
    /* [44] */ &FrexpResult_,
    /* [45] */ &FrexpResultVec_,
    /* [46] */ &Fiu32_,
    /* [47] */ &Fi32_,
    /* [48] */ &Iu32_,
    /* [49] */ &Scalar_,
    /* [50] */ &ScalarNoF32_,
    /* [51] */ &ScalarNoI32_,
    /* [52] */ &ScalarNoU32_,
    /* [53] */ &ScalarNoBool_,
  };

  /// The open-numbers, and number matchers
  NumberMatcher const* const number[12] = {
    /* [0] */ &open_number_0_,
    /* [1] */ &open_number_1_,
    /* [2] */ &open_number_2_,
    /* [3] */ &F32TexelFormat_,
    /* [4] */ &I32TexelFormat_,
    /* [5] */ &U32TexelFormat_,
    /* [6] */ &WriteOnly_,
    /* [7] */ &FunctionPrivateWorkgroup_,
    /* [8] */ &WorkgroupOrStorage_,
    /* [9] */ &Storage_,
    /* [10] */ &Write_,
    /* [11] */ &ReadWrite_,
  };
};

Matchers::Matchers() = default;
Matchers::~Matchers() = default;

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

// Assert that the MatcherIndex is big enough to index all the matchers, plus
// kNoMatcher.
static_assert(static_cast<int>(sizeof(kMatcherIndices) / sizeof(kMatcherIndices[0])) <
              static_cast<int>(std::numeric_limits<MatcherIndex>::max() - 1),
              "MatcherIndex is not large enough to index kMatcherIndices");

constexpr ParameterInfo kParameters[] = {
  {
    /* [0] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [1] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [2] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [3] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [4] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [5] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [6] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [7] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [8] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [9] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [10] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [11] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [12] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [13] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [14] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [15] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [16] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [17] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [18] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [19] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [20] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [21] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [22] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [23] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [24] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [25] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [26] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [27] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [28] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [29] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [30] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [31] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [32] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [33] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [34] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [35] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [36] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [37] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [38] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [39] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [40] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [41] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [42] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [43] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [44] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [45] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [46] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [47] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [48] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [49] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [50] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [51] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [52] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [53] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [54] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [55] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [56] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [57] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [58] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [59] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [60] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [61] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [62] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [63] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [64] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [65] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [66] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [67] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [68] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [69] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [70] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [71] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [72] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [73] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [74] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [75] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [76] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [77] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [78] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [79] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [80] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [81] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [82] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [83] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [84] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [85] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [86] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [87] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [88] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [89] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [90] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [91] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [92] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [93] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [94] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [95] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [96] */
    /* usage */ ParameterUsage::kComponent,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [97] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [98] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [99] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [100] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [101] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [102] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [103] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [104] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [105] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [106] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [107] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [108] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [109] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [110] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [111] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [112] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [113] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [114] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [115] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [116] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [117] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [118] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [119] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [120] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[193],
  },
  {
    /* [121] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [122] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [123] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [124] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [125] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [126] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [127] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [128] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [129] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [130] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [131] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [132] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [133] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [134] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [135] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [136] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [137] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [138] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [139] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [140] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [141] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [142] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [143] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [144] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [145] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [146] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [147] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [148] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [149] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [150] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [151] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [152] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [153] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [154] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [155] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [156] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [157] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [158] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [159] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [160] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [161] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [162] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [163] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [164] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [165] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[193],
  },
  {
    /* [166] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [167] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [168] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [169] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [170] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [171] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [172] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [173] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [174] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [175] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [176] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [177] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [178] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [179] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [180] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [181] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [182] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [183] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [184] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [185] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [186] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [187] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [188] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [189] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [190] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [191] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [192] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [193] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [194] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [195] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [196] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [197] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [198] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [199] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [200] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [201] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [202] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [203] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [204] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [205] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [206] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [207] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [208] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [209] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [210] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[191],
  },
  {
    /* [211] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [212] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [213] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [214] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [215] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [216] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [217] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [218] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [219] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [220] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [221] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [222] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [223] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [224] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [225] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [226] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [227] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [228] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [229] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [230] */
    /* usage */ ParameterUsage::kComponent,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [231] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[149],
  },
  {
    /* [232] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [233] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [234] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [235] */
    /* usage */ ParameterUsage::kComponent,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [236] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [237] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [238] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [239] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [240] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [241] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [242] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [243] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [244] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [245] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [246] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [247] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [248] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [249] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [250] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [251] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [252] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [253] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [254] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [255] */
    /* usage */ ParameterUsage::kComponent,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [256] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[135],
  },
  {
    /* [257] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [258] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [259] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [260] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [261] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [262] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [263] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [264] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [265] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [266] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [267] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [268] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [269] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [270] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[193],
  },
  {
    /* [271] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [272] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [273] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [274] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [275] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [276] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [277] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [278] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [279] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [280] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [281] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [282] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [283] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [284] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [285] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [286] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [287] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [288] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [289] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [290] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [291] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [292] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [293] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [294] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [295] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [296] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [297] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [298] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [299] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [300] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [301] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [302] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [303] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [304] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [305] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [306] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [307] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[191],
  },
  {
    /* [308] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [309] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [310] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [311] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [312] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [313] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [314] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [315] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [316] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [317] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [318] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [319] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [320] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [321] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [322] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [323] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [324] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [325] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [326] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [327] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [328] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [329] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [330] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [331] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [332] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [333] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [334] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [335] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [336] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [337] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [338] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [339] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[191],
  },
  {
    /* [340] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [341] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [342] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [343] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [344] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [345] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [346] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [347] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [348] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [349] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [350] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [351] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[193],
  },
  {
    /* [352] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [353] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [354] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [355] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [356] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [357] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [358] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [359] */
    /* usage */ ParameterUsage::kComponent,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [360] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[135],
  },
  {
    /* [361] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [362] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [363] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[185],
  },
  {
    /* [364] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [365] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [366] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [367] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [368] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [369] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [370] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [371] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [372] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [373] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [374] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [375] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [376] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [377] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [378] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [379] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [380] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [381] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [382] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [383] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[84],
  },
  {
    /* [384] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [385] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [386] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[109],
  },
  {
    /* [387] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[60],
  },
  {
    /* [388] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [389] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [390] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [391] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [392] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[196],
  },
  {
    /* [393] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [394] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [395] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [396] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [397] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [398] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [399] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[47],
  },
  {
    /* [400] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [401] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [402] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[145],
  },
  {
    /* [403] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [404] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [405] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [406] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [407] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [408] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [409] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [410] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [411] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [412] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [413] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [414] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [415] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [416] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [417] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [418] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [419] */
    /* usage */ ParameterUsage::kX,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [420] */
    /* usage */ ParameterUsage::kY,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [421] */
    /* usage */ ParameterUsage::kZ,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [422] */
    /* usage */ ParameterUsage::kW,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [423] */
    /* usage */ ParameterUsage::kComponent,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [424] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [425] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [426] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [427] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [428] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [429] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [430] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [431] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [432] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [433] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [434] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [435] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [436] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [437] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [438] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [439] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [440] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [441] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [442] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [443] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [444] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [445] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [446] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [447] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [448] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [449] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [450] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [451] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [452] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [453] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [454] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [455] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [456] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[201],
  },
  {
    /* [457] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [458] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [459] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [460] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [461] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [462] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [463] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [464] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [465] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [466] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [467] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [468] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [469] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [470] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [471] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [472] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [473] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [474] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [475] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [476] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [477] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[90],
  },
  {
    /* [478] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [479] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[109],
  },
  {
    /* [480] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[87],
  },
  {
    /* [481] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [482] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[109],
  },
  {
    /* [483] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[69],
  },
  {
    /* [484] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [485] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[109],
  },
  {
    /* [486] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[66],
  },
  {
    /* [487] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [488] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [489] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[63],
  },
  {
    /* [490] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [491] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [492] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[57],
  },
  {
    /* [493] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [494] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [495] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [496] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [497] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [498] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [499] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [500] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [501] */
    /* usage */ ParameterUsage::kX,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [502] */
    /* usage */ ParameterUsage::kY,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [503] */
    /* usage */ ParameterUsage::kZw,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [504] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [505] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [506] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [507] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [508] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [509] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [510] */
    /* usage */ ParameterUsage::kX,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [511] */
    /* usage */ ParameterUsage::kYz,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [512] */
    /* usage */ ParameterUsage::kW,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [513] */
    /* usage */ ParameterUsage::kXy,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [514] */
    /* usage */ ParameterUsage::kZ,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [515] */
    /* usage */ ParameterUsage::kW,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [516] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[54],
  },
  {
    /* [517] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [518] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[145],
  },
  {
    /* [519] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[51],
  },
  {
    /* [520] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [521] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[145],
  },
  {
    /* [522] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [523] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [524] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [525] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [526] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [527] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [528] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [529] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [530] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [531] */
    /* usage */ ParameterUsage::kX,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [532] */
    /* usage */ ParameterUsage::kY,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [533] */
    /* usage */ ParameterUsage::kZ,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [534] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [535] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [536] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [537] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[43],
  },
  {
    /* [538] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [539] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[145],
  },
  {
    /* [540] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[129],
  },
  {
    /* [541] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [542] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [543] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[135],
  },
  {
    /* [544] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [545] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [546] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [547] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [548] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [549] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [550] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [551] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [552] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [553] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [554] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [555] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [556] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [557] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [558] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [559] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [560] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [561] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [562] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [563] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [564] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[191],
  },
  {
    /* [565] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [566] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [567] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [568] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [569] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [570] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[189],
  },
  {
    /* [571] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [572] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [573] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[143],
  },
  {
    /* [574] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[121],
  },
  {
    /* [575] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [576] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[153],
  },
  {
    /* [577] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [578] */
    /* usage */ ParameterUsage::kSampleIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [579] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [580] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [581] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [582] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [583] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [584] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [585] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[181],
  },
  {
    /* [586] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [587] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [588] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[202],
  },
  {
    /* [589] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [590] */
    /* usage */ ParameterUsage::kSampleIndex,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [591] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [592] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [593] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [594] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [595] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[195],
  },
  {
    /* [596] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [597] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [598] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [599] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [600] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [601] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [602] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [603] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [604] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [605] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [606] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [607] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [608] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [609] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [610] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [611] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[129],
  },
  {
    /* [612] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [613] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [614] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [615] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[135],
  },
  {
    /* [616] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [617] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [618] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [619] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [620] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [621] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [622] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [623] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[143],
  },
  {
    /* [624] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [625] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [626] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [627] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [628] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [629] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [630] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [631] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[149],
  },
  {
    /* [632] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [633] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [634] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [635] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [636] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [637] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [638] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [639] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [640] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [641] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [642] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [643] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [644] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [645] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [646] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [647] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [648] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [649] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [650] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [651] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [652] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [653] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [654] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [655] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [656] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [657] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [658] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [659] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [660] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [661] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [662] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [663] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[19],
  },
  {
    /* [664] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[23],
  },
  {
    /* [665] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[72],
  },
  {
    /* [666] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [667] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [668] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [669] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [670] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [671] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [672] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [673] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [674] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [675] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [676] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [677] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [678] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [679] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [680] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [681] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [682] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [683] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [684] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [685] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [686] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [687] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [688] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [689] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [690] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [691] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [692] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [693] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [694] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [695] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [696] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [697] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [698] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [699] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [700] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [701] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [702] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [703] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [704] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [705] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [706] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [707] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [708] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [709] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [710] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [711] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [712] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [713] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [714] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [715] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [716] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [717] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [718] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [719] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [720] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [721] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [722] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [723] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [724] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [725] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [726] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [727] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[201],
  },
  {
    /* [728] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[105],
  },
  {
    /* [729] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [730] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [731] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [732] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [733] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [734] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [735] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [736] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [737] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [738] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [739] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [740] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [741] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [742] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [743] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [744] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [745] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [746] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [747] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [748] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [749] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [750] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [751] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [752] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [753] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [754] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[96],
  },
  {
    /* [755] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [756] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [757] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [758] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[96],
  },
  {
    /* [759] */
    /* usage */ ParameterUsage::kX,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [760] */
    /* usage */ ParameterUsage::kY,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [761] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [762] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [763] */
    /* usage */ ParameterUsage::kXy,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [764] */
    /* usage */ ParameterUsage::kZ,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [765] */
    /* usage */ ParameterUsage::kX,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [766] */
    /* usage */ ParameterUsage::kYz,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [767] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [768] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [769] */
    /* usage */ ParameterUsage::kXy,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [770] */
    /* usage */ ParameterUsage::kZw,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [771] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [772] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [773] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [774] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [775] */
    /* usage */ ParameterUsage::kXyz,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [776] */
    /* usage */ ParameterUsage::kW,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [777] */
    /* usage */ ParameterUsage::kX,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [778] */
    /* usage */ ParameterUsage::kZyw,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [779] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [780] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [781] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [782] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [783] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [784] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [785] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [786] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [787] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [788] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [789] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [790] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [791] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [792] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[119],
  },
  {
    /* [793] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [794] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [795] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [796] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [797] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [798] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [799] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [800] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [801] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [802] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[93],
  },
  {
    /* [803] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [804] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [805] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [806] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [807] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [808] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [809] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[15],
  },
  {
    /* [810] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [811] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [812] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [813] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [814] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [815] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [816] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [817] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [818] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [819] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [820] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [821] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [822] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [823] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [824] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [825] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [826] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [827] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [828] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [829] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [830] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [831] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [832] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [833] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [834] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [835] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [836] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [837] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [838] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [839] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [840] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[34],
  },
  {
    /* [841] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [842] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [843] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [844] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[202],
  },
  {
    /* [845] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[153],
  },
  {
    /* [846] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [847] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[0],
  },
  {
    /* [848] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [849] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [850] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [851] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[149],
  },
  {
    /* [852] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [853] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[143],
  },
  {
    /* [854] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [855] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[135],
  },
  {
    /* [856] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[129],
  },
  {
    /* [857] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[34],
  },
  {
    /* [858] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [859] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [860] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [861] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [862] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [863] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [864] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [865] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [866] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[149],
  },
  {
    /* [867] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [868] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [869] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [870] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [871] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [872] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [873] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [874] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [875] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [876] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [877] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [878] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [879] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [880] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [881] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [882] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [883] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[201],
  },
  {
    /* [884] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[75],
  },
  {
    /* [885] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [886] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[78],
  },
  {
    /* [887] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[81],
  },
  {
    /* [888] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[202],
  },
  {
    /* [889] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[197],
  },
  {
    /* [890] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[198],
  },
  {
    /* [891] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[199],
  },
  {
    /* [892] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[200],
  },
  {
    /* [893] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[153],
  },
  {
    /* [894] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[149],
  },
  {
    /* [895] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [896] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[143],
  },
  {
    /* [897] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [898] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[135],
  },
  {
    /* [899] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[129],
  },
  {
    /* [900] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [901] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [902] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [903] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [904] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [905] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [906] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [907] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [908] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[11],
  },
  {
    /* [909] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [910] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [911] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [912] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [913] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [914] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [915] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [916] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [917] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [918] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [919] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[187],
  },
  {
    /* [920] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[58],
  },
  {
    /* [921] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [922] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [923] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [924] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [925] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [926] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [927] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [928] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [929] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [930] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [931] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[177],
  },
  {
    /* [932] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[101],
  },
  {
    /* [933] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [934] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [935] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[103],
  },
  {
    /* [936] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[103],
  },
  {
    /* [937] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[103],
  },
  {
    /* [938] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[103],
  },
  {
    /* [939] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [940] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[113],
  },
  {
    /* [941] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [942] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [943] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [944] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [945] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[117],
  },
  {
    /* [946] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[117],
  },
  {
    /* [947] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[117],
  },
  {
    /* [948] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[117],
  },
  {
    /* [949] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [950] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[127],
  },
  {
    /* [951] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [952] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [953] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[37],
  },
  {
    /* [954] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [955] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [956] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [957] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [958] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[109],
  },
  {
    /* [959] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [960] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [961] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [962] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [963] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [964] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[155],
  },
  {
    /* [965] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [966] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [967] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [968] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[173],
  },
  {
    /* [969] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[45],
  },
  {
    /* [970] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [971] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [972] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [973] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [974] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[4],
  },
  {
    /* [975] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [976] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[5],
  },
  {
    /* [977] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[99],
  },
  {
    /* [978] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[21],
  },
  {
    /* [979] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[161],
  },
  {
    /* [980] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [981] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [982] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[31],
  },
  {
    /* [983] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [984] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[165],
  },
  {
    /* [985] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[1],
  },
  {
    /* [986] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[40],
  },
  {
    /* [987] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[44],
  },
  {
    /* [988] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[169],
  },
  {
    /* [989] */
    /* usage */ ParameterUsage::kNone,
    /* matcher indices */ &kMatcherIndices[109],
  },
};

constexpr OpenTypeInfo kOpenTypes[] = {
  {
    /* [0] */
    /* name */ "T",
    /* matcher index */ 2,
  },
  {
    /* [1] */
    /* name */ "U",
    /* matcher index */ 53,
  },
  {
    /* [2] */
    /* name */ "T",
    /* matcher index */ 3,
  },
  {
    /* [3] */
    /* name */ "U",
    /* matcher index */ 50,
  },
  {
    /* [4] */
    /* name */ "T",
    /* matcher index */ 4,
  },
  {
    /* [5] */
    /* name */ "U",
    /* matcher index */ 51,
  },
  {
    /* [6] */
    /* name */ "T",
    /* matcher index */ 5,
  },
  {
    /* [7] */
    /* name */ "U",
    /* matcher index */ 52,
  },
  {
    /* [8] */
    /* name */ "T",
    /* matcher index */ 46,
  },
  {
    /* [9] */
    /* name */ "f32",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [10] */
    /* name */ "T",
    /* matcher index */ 48,
  },
  {
    /* [11] */
    /* name */ "T",
    /* matcher index */ 49,
  },
  {
    /* [12] */
    /* name */ "T",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [13] */
    /* name */ "T",
    /* matcher index */ 53,
  },
  {
    /* [14] */
    /* name */ "T",
    /* matcher index */ 50,
  },
  {
    /* [15] */
    /* name */ "T",
    /* matcher index */ 52,
  },
  {
    /* [16] */
    /* name */ "T",
    /* matcher index */ 51,
  },
  {
    /* [17] */
    /* name */ "T",
    /* matcher index */ 47,
  },
};

constexpr OpenNumberInfo kOpenNumbers[] = {
  {
    /* [0] */
    /* name */ "K",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [1] */
    /* name */ "C",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [2] */
    /* name */ "R",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [3] */
    /* name */ "F",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [4] */
    /* name */ "A",
    /* matcher index */ 6,
  },
  {
    /* [5] */
    /* name */ "M",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [6] */
    /* name */ "N",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [7] */
    /* name */ "M",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [8] */
    /* name */ "A",
    /* matcher index */ kNoMatcher,
  },
  {
    /* [9] */
    /* name */ "S",
    /* matcher index */ 8,
  },
};

constexpr OverloadInfo kOverloads[] = {
  {
    /* [0] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[899],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [1] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[611],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [2] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[898],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [3] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[615],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [4] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[897],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [5] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[619],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [6] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[896],
    /* return matcher indices */ &kMatcherIndices[121],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [7] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[623],
    /* return matcher indices */ &kMatcherIndices[121],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [8] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[895],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [9] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[627],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [10] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[894],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [11] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[631],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [12] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[893],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [13] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[892],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [14] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[637],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [15] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[891],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [16] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[641],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [17] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[890],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [18] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[645],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [19] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[889],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [20] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[649],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [21] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[888],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [22] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[3],
    /* parameters */ &kParameters[887],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [23] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[3],
    /* parameters */ &kParameters[886],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [24] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[3],
    /* parameters */ &kParameters[840],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [25] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[3],
    /* parameters */ &kParameters[884],
    /* return matcher indices */ &kMatcherIndices[121],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [26] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[883],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [27] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[585],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [28] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[582],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [29] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[367],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [30] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[363],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [31] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[215],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [32] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[570],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [33] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[355],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [34] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[564],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [35] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[351],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [36] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[546],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [37] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[347],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [38] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[343],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [39] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[200],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [40] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[534],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [41] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[335],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [42] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[319],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [43] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[195],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [44] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[190],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [45] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[126],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [46] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[327],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [47] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[175],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [48] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[339],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [49] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[165],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [50] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[371],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [51] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[155],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [52] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[150],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [53] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[72],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [54] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[379],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [55] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[170],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [56] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[456],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [57] */
    /* num parameters */ 0,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [58] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[950],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [59] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[951],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [60] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[419],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [61] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[513],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [62] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[510],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [63] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[501],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [64] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[769],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [65] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[775],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [66] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[777],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [67] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[959],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [68] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[4],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[960],
    /* return matcher indices */ &kMatcherIndices[133],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [69] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[6],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[961],
    /* return matcher indices */ &kMatcherIndices[145],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [70] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[0],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[962],
    /* return matcher indices */ &kMatcherIndices[151],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [71] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[359],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [72] */
    /* num parameters */ 5,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[255],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [73] */
    /* num parameters */ 5,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[235],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [74] */
    /* num parameters */ 6,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[96],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [75] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[423],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [76] */
    /* num parameters */ 5,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[230],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [77] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[447],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [78] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[415],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [79] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[411],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [80] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[225],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [81] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[594],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [82] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[395],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [83] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[477],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [84] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[480],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [85] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[383],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [86] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[483],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [87] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[486],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [88] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[489],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [89] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[387],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [90] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[492],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [91] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[516],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [92] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[519],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [93] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[399],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [94] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[537],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [95] */
    /* num parameters */ 0,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[113],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [96] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[940],
    /* return matcher indices */ &kMatcherIndices[113],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [97] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[941],
    /* return matcher indices */ &kMatcherIndices[113],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [98] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[531],
    /* return matcher indices */ &kMatcherIndices[113],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [99] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[763],
    /* return matcher indices */ &kMatcherIndices[113],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [100] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[765],
    /* return matcher indices */ &kMatcherIndices[113],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [101] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[945],
    /* return matcher indices */ &kMatcherIndices[119],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [102] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[4],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[946],
    /* return matcher indices */ &kMatcherIndices[121],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [103] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[6],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[947],
    /* return matcher indices */ &kMatcherIndices[123],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [104] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[0],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[948],
    /* return matcher indices */ &kMatcherIndices[125],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [105] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[856],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [106] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[855],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [107] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[854],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [108] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[853],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [109] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[852],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [110] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[851],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [111] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[850],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [112] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[849],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [113] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[848],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [114] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[846],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [115] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[540],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [116] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[543],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [117] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[323],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [118] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[573],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [119] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[576],
    /* return matcher indices */ &kMatcherIndices[127],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [120] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[579],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [121] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[407],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [122] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[588],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [123] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[727],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [124] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[685],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [125] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[681],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [126] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[679],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [127] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[673],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [128] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[671],
    /* return matcher indices */ &kMatcherIndices[11],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [129] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[669],
    /* return matcher indices */ &kMatcherIndices[11],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [130] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[1],
    /* parameters */ &kParameters[667],
    /* return matcher indices */ &kMatcherIndices[72],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [131] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[1],
    /* parameters */ &kParameters[665],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [132] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 3,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[0],
    /* parameters */ &kParameters[663],
    /* return matcher indices */ &kMatcherIndices[27],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [133] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[331],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [134] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[180],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [135] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[290],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [136] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[132],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [137] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[315],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [138] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[250],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [139] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[307],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [140] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[270],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [141] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[240],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [142] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[84],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [143] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[102],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [144] */
    /* num parameters */ 7,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[65],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [145] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[220],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [146] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[114],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [147] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[210],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [148] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[120],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [149] */
    /* num parameters */ 0,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[101],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [150] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[932],
    /* return matcher indices */ &kMatcherIndices[101],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [151] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[933],
    /* return matcher indices */ &kMatcherIndices[101],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [152] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[759],
    /* return matcher indices */ &kMatcherIndices[101],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [153] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[935],
    /* return matcher indices */ &kMatcherIndices[99],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [154] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[4],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[936],
    /* return matcher indices */ &kMatcherIndices[105],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [155] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[6],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[937],
    /* return matcher indices */ &kMatcherIndices[107],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [156] */
    /* num parameters */ 1,
    /* num open types */ 2,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[0],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[938],
    /* return matcher indices */ &kMatcherIndices[111],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [157] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[391],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [158] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[205],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [159] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[185],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [160] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[138],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [161] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[375],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [162] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[160],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [163] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[303],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [164] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[265],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [165] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[260],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [166] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[144],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [167] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[311],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [168] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[245],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [169] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[299],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [170] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[280],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [171] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[285],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [172] */
    /* num parameters */ 6,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[108],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [173] */
    /* num parameters */ 4,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[295],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [174] */
    /* num parameters */ 5,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[275],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [175] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[45],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [176] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[969],
    /* return matcher indices */ &kMatcherIndices[45],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [177] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[970],
    /* return matcher indices */ &kMatcherIndices[49],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [178] */
    /* num parameters */ 6,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[90],
    /* return matcher indices */ &kMatcherIndices[49],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [179] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[781],
    /* return matcher indices */ &kMatcherIndices[49],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [180] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[169],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [181] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[988],
    /* return matcher indices */ &kMatcherIndices[169],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [182] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[983],
    /* return matcher indices */ &kMatcherIndices[171],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [183] */
    /* num parameters */ 12,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[16],
    /* return matcher indices */ &kMatcherIndices[171],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [184] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[468],
    /* return matcher indices */ &kMatcherIndices[171],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [185] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[173],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [186] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[968],
    /* return matcher indices */ &kMatcherIndices[173],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [187] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[957],
    /* return matcher indices */ &kMatcherIndices[175],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [188] */
    /* num parameters */ 8,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[57],
    /* return matcher indices */ &kMatcherIndices[175],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [189] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[431],
    /* return matcher indices */ &kMatcherIndices[175],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [190] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[155],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [191] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[964],
    /* return matcher indices */ &kMatcherIndices[155],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [192] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[965],
    /* return matcher indices */ &kMatcherIndices[157],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [193] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[427],
    /* return matcher indices */ &kMatcherIndices[157],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [194] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[779],
    /* return matcher indices */ &kMatcherIndices[157],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [195] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[161],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [196] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[979],
    /* return matcher indices */ &kMatcherIndices[161],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [197] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[980],
    /* return matcher indices */ &kMatcherIndices[163],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [198] */
    /* num parameters */ 6,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[78],
    /* return matcher indices */ &kMatcherIndices[163],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [199] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[474],
    /* return matcher indices */ &kMatcherIndices[163],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [200] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[4],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [201] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[974],
    /* return matcher indices */ &kMatcherIndices[4],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [202] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[975],
    /* return matcher indices */ &kMatcherIndices[159],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [203] */
    /* num parameters */ 8,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[49],
    /* return matcher indices */ &kMatcherIndices[159],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [204] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[783],
    /* return matcher indices */ &kMatcherIndices[159],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [205] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[867],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [206] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[866],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [207] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[865],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [208] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[864],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [209] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[3],
    /* parameters */ &kParameters[857],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [210] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[177],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [211] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[931],
    /* return matcher indices */ &kMatcherIndices[177],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [212] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[928],
    /* return matcher indices */ &kMatcherIndices[179],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [213] */
    /* num parameters */ 12,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[28],
    /* return matcher indices */ &kMatcherIndices[179],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [214] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[435],
    /* return matcher indices */ &kMatcherIndices[179],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [215] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[695],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [216] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[693],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [217] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[691],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [218] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[689],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [219] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[687],
    /* return matcher indices */ &kMatcherIndices[11],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [220] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[705],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [221] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[703],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [222] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[701],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [223] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[699],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [224] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[697],
    /* return matcher indices */ &kMatcherIndices[11],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [225] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[187],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [226] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[919],
    /* return matcher indices */ &kMatcherIndices[187],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [227] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[912],
    /* return matcher indices */ &kMatcherIndices[141],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [228] */
    /* num parameters */ 16,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[0],
    /* return matcher indices */ &kMatcherIndices[141],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [229] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[443],
    /* return matcher indices */ &kMatcherIndices[141],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [230] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[165],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [231] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[9],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[984],
    /* return matcher indices */ &kMatcherIndices[165],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [232] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[985],
    /* return matcher indices */ &kMatcherIndices[167],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [233] */
    /* num parameters */ 9,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[40],
    /* return matcher indices */ &kMatcherIndices[167],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [234] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[2],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[471],
    /* return matcher indices */ &kMatcherIndices[167],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [235] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[633],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [236] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[629],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [237] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[625],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [238] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[621],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [239] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[653],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [240] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[651],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [241] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[647],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [242] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[643],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [243] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[661],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [244] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[659],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [245] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[657],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [246] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[655],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [247] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[617],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [248] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[613],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [249] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[609],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [250] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[607],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [251] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [252] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[920],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [253] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[16],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[921],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [254] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [255] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[929],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [256] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[13],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[930],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [257] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[522],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [258] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[525],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [259] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[528],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [260] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [261] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[923],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [262] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[15],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[924],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [263] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [264] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[926],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [265] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[14],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[927],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [266] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[459],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [267] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[462],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [268] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[465],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [269] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[858],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [270] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[859],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [271] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[871],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [272] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[872],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [273] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[869],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [274] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[870],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [275] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[439],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [276] */
    /* num parameters */ 4,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[403],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [277] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[875],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [278] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[876],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [279] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[677],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [280] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[801],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [281] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[878],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [282] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[879],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [283] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[880],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [284] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[881],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [285] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[882],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [286] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[885],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [287] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[737],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [288] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[789],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [289] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[787],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [290] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[785],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [291] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[843],
    /* return matcher indices */ &kMatcherIndices[204],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [292] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[868],
    /* return matcher indices */ &kMatcherIndices[139],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [293] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[973],
    /* return matcher indices */ &kMatcherIndices[203],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [294] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[905],
    /* return matcher indices */ &kMatcherIndices[115],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [295] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[841],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [296] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[842],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [297] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[561],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [298] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[567],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [299] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[873],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [300] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[874],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [301] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[838],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [302] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[839],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [303] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[836],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [304] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[837],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [305] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[834],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [306] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[835],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [307] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[773],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [308] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[771],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [309] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[956],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [310] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[955],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [311] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[495],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [312] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[498],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [313] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[831],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [314] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[833],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [315] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[954],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [316] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[953],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [317] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[944],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [318] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[943],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [319] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[829],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [320] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[830],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [321] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[942],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [322] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[934],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [323] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[918],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [324] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[917],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [325] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[916],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [326] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[915],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [327] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[549],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [328] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[552],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [329] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[555],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kIsDeprecated),
  },
  {
    /* [330] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[558],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kIsDeprecated),
  },
  {
    /* [331] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[914],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [332] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[913],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [333] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[745],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [334] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[743],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [335] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[826],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [336] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[827],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [337] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[911],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [338] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[877],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [339] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[910],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [340] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[909],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [341] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[755],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [342] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[757],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [343] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[907],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [344] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[906],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [345] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[751],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [346] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[753],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [347] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[824],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [348] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[825],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [349] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[739],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [350] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[741],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [351] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[733],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [352] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[735],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [353] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[707],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [354] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[729],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [355] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[675],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [356] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[683],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [357] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[812],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [358] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[823],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [359] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[807],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [360] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[808],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [361] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[805],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [362] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[806],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [363] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[803],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [364] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[804],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
  },
  {
    /* [365] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[793],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [366] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[795],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [367] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[845],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [368] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[844],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [369] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[811],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [370] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[810],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [371] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[814],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [372] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[813],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [373] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[601],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [374] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[11],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[599],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [375] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[816],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [376] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[815],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [377] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[818],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [378] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[817],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [379] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[820],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [380] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[819],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [381] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[822],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [382] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[821],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [383] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[453],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [384] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[450],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [385] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[832],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [386] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[828],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [387] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[731],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [388] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[761],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [389] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[639],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [390] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[635],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [391] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[966],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [392] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[952],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [393] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[976],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [394] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[971],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [395] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[978],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [396] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[986],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [397] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[939],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [398] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[949],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [399] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[922],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [400] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[925],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [401] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[17],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[862],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [402] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[17],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[863],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [403] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[860],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [404] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[861],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [405] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[963],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [406] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[900],
    /* return matcher indices */ &kMatcherIndices[37],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [407] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[747],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [408] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[749],
    /* return matcher indices */ &kMatcherIndices[40],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [409] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[904],
    /* return matcher indices */ &kMatcherIndices[99],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [410] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[711],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [411] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[713],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [412] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[715],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [413] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[717],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [414] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[719],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [415] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[721],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [416] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[723],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [417] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[725],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [418] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[847],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [419] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[605],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [420] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[603],
    /* return matcher indices */ &kMatcherIndices[21],
    /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [421] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[967],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [422] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [423] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[901],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [424] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[902],
    /* return matcher indices */ &kMatcherIndices[109],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [425] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[903],
    /* return matcher indices */ &kMatcherIndices[99],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [426] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[709],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [427] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[987],
    /* return matcher indices */ &kMatcherIndices[99],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [428] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 2,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[5],
    /* parameters */ &kParameters[908],
    /* return matcher indices */ &kMatcherIndices[23],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [429] */
    /* num parameters */ 0,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[990],
    /* return matcher indices */ nullptr,
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [430] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[507],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [431] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[767],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [432] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[989],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [433] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[958],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [434] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[972],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [435] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[977],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [436] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[982],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [437] */
    /* num parameters */ 3,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[504],
    /* return matcher indices */ &kMatcherIndices[31],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [438] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[597],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [439] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[799],
    /* return matcher indices */ &kMatcherIndices[58],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [440] */
    /* num parameters */ 2,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[8],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[797],
    /* return matcher indices */ &kMatcherIndices[1],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [441] */
    /* num parameters */ 1,
    /* num open types */ 0,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[6],
    /* parameters */ &kParameters[809],
    /* return matcher indices */ &kMatcherIndices[5],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [442] */
    /* num parameters */ 2,
    /* num open types */ 0,
    /* num open numbers */ 0,
    /* open types */ &kOpenTypes[18],
    /* open numbers */ &kOpenNumbers[10],
    /* parameters */ &kParameters[791],
    /* return matcher indices */ &kMatcherIndices[119],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [443] */
    /* num parameters */ 1,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[12],
    /* open numbers */ &kOpenNumbers[8],
    /* parameters */ &kParameters[981],
    /* return matcher indices */ &kMatcherIndices[44],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
  {
    /* [444] */
    /* num parameters */ 3,
    /* num open types */ 1,
    /* num open numbers */ 1,
    /* open types */ &kOpenTypes[10],
    /* open numbers */ &kOpenNumbers[9],
    /* parameters */ &kParameters[591],
    /* return matcher indices */ &kMatcherIndices[101],
    /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
  },
};

constexpr IntrinsicInfo kBuiltins[] = {
  {
    /* [0] */
    /* fn abs<T : fiu32>(T) -> T */
    /* fn abs<N : num, T : fiu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[405],
  },
  {
    /* [1] */
    /* fn acos(f32) -> f32 */
    /* fn acos<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[399],
  },
  {
    /* [2] */
    /* fn all(bool) -> bool */
    /* fn all<N : num>(vec<N, bool>) -> bool */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[397],
  },
  {
    /* [3] */
    /* fn any(bool) -> bool */
    /* fn any<N : num>(vec<N, bool>) -> bool */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[395],
  },
  {
    /* [4] */
    /* fn arrayLength<T, A : access>(ptr<storage, array<T>, A>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[443],
  },
  {
    /* [5] */
    /* fn asin(f32) -> f32 */
    /* fn asin<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[393],
  },
  {
    /* [6] */
    /* fn atan(f32) -> f32 */
    /* fn atan<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[391],
  },
  {
    /* [7] */
    /* fn atan2(f32, f32) -> f32 */
    /* fn atan2<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[387],
  },
  {
    /* [8] */
    /* fn ceil(f32) -> f32 */
    /* fn ceil<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[385],
  },
  {
    /* [9] */
    /* fn clamp<T : fiu32>(T, T, T) -> T */
    /* fn clamp<N : num, T : fiu32>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[383],
  },
  {
    /* [10] */
    /* fn cos(f32) -> f32 */
    /* fn cos<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[381],
  },
  {
    /* [11] */
    /* fn cosh(f32) -> f32 */
    /* fn cosh<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[379],
  },
  {
    /* [12] */
    /* fn countLeadingZeros<T : iu32>(T) -> T */
    /* fn countLeadingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[377],
  },
  {
    /* [13] */
    /* fn countOneBits<T : iu32>(T) -> T */
    /* fn countOneBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[375],
  },
  {
    /* [14] */
    /* fn countTrailingZeros<T : iu32>(T) -> T */
    /* fn countTrailingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[371],
  },
  {
    /* [15] */
    /* fn cross(vec3<f32>, vec3<f32>) -> vec3<f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[442],
  },
  {
    /* [16] */
    /* fn degrees(f32) -> f32 */
    /* fn degrees<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[369],
  },
  {
    /* [17] */
    /* fn determinant<N : num>(mat<N, N, f32>) -> f32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[441],
  },
  {
    /* [18] */
    /* fn distance(f32, f32) -> f32 */
    /* fn distance<N : num>(vec<N, f32>, vec<N, f32>) -> f32 */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[365],
  },
  {
    /* [19] */
    /* fn dot<N : num, T : fiu32>(vec<N, T>, vec<N, T>) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[440],
  },
  {
    /* [20] */
    /* fn dot4I8Packed(u32, u32) -> i32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[439],
  },
  {
    /* [21] */
    /* fn dot4U8Packed(u32, u32) -> u32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[438],
  },
  {
    /* [22] */
    /* fn dpdx(f32) -> f32 */
    /* fn dpdx<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[363],
  },
  {
    /* [23] */
    /* fn dpdxCoarse(f32) -> f32 */
    /* fn dpdxCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[361],
  },
  {
    /* [24] */
    /* fn dpdxFine(f32) -> f32 */
    /* fn dpdxFine<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[359],
  },
  {
    /* [25] */
    /* fn dpdy(f32) -> f32 */
    /* fn dpdy<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[357],
  },
  {
    /* [26] */
    /* fn dpdyCoarse(f32) -> f32 */
    /* fn dpdyCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[347],
  },
  {
    /* [27] */
    /* fn dpdyFine(f32) -> f32 */
    /* fn dpdyFine<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[335],
  },
  {
    /* [28] */
    /* fn exp(f32) -> f32 */
    /* fn exp<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[319],
  },
  {
    /* [29] */
    /* fn exp2(f32) -> f32 */
    /* fn exp2<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[313],
  },
  {
    /* [30] */
    /* 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 */ &kOverloads[311],
  },
  {
    /* [31] */
    /* fn faceForward<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[437],
  },
  {
    /* [32] */
    /* fn firstLeadingBit<T : iu32>(T) -> T */
    /* fn firstLeadingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[305],
  },
  {
    /* [33] */
    /* fn firstTrailingBit<T : iu32>(T) -> T */
    /* fn firstTrailingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[303],
  },
  {
    /* [34] */
    /* fn floor(f32) -> f32 */
    /* fn floor<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[301],
  },
  {
    /* [35] */
    /* fn fma(f32, f32, f32) -> f32 */
    /* fn fma<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[297],
  },
  {
    /* [36] */
    /* fn fract(f32) -> f32 */
    /* fn fract<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[295],
  },
  {
    /* [37] */
    /* fn frexp(f32) -> __frexp_result */
    /* fn frexp<N : num>(vec<N, f32>) -> __frexp_result_vec<N> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[291],
  },
  {
    /* [38] */
    /* fn fwidth(f32) -> f32 */
    /* fn fwidth<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[273],
  },
  {
    /* [39] */
    /* fn fwidthCoarse(f32) -> f32 */
    /* fn fwidthCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[271],
  },
  {
    /* [40] */
    /* fn fwidthFine(f32) -> f32 */
    /* fn fwidthFine<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[299],
  },
  {
    /* [41] */
    /* 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 */ &kOverloads[275],
  },
  {
    /* [42] */
    /* fn inverseSqrt(f32) -> f32 */
    /* fn inverseSqrt<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[277],
  },
  {
    /* [43] */
    /* fn ldexp(f32, i32) -> f32 */
    /* fn ldexp<N : num>(vec<N, f32>, vec<N, i32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[279],
  },
  {
    /* [44] */
    /* fn length(f32) -> f32 */
    /* fn length<N : num>(vec<N, f32>) -> f32 */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[281],
  },
  {
    /* [45] */
    /* fn log(f32) -> f32 */
    /* fn log<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[283],
  },
  {
    /* [46] */
    /* fn log2(f32) -> f32 */
    /* fn log2<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[285],
  },
  {
    /* [47] */
    /* fn max<T : fiu32>(T, T) -> T */
    /* fn max<N : num, T : fiu32>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[287],
  },
  {
    /* [48] */
    /* fn min<T : fiu32>(T, T) -> T */
    /* fn min<N : num, T : fiu32>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[289],
  },
  {
    /* [49] */
    /* fn mix(f32, f32, f32) -> f32 */
    /* fn mix<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* fn mix<N : num>(vec<N, f32>, vec<N, f32>, f32) -> vec<N, f32> */
    /* num overloads */ 3,
    /* overloads */ &kOverloads[266],
  },
  {
    /* [50] */
    /* fn modf(f32) -> __modf_result */
    /* fn modf<N : num>(vec<N, f32>) -> __modf_result_vec<N> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[293],
  },
  {
    /* [51] */
    /* fn normalize<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[436],
  },
  {
    /* [52] */
    /* fn pack2x16float(vec2<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[435],
  },
  {
    /* [53] */
    /* fn pack2x16snorm(vec2<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[434],
  },
  {
    /* [54] */
    /* fn pack2x16unorm(vec2<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[421],
  },
  {
    /* [55] */
    /* fn pack4x8snorm(vec4<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[433],
  },
  {
    /* [56] */
    /* fn pack4x8unorm(vec4<f32>) -> u32 */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[432],
  },
  {
    /* [57] */
    /* fn pow(f32, f32) -> f32 */
    /* fn pow<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[307],
  },
  {
    /* [58] */
    /* fn radians(f32) -> f32 */
    /* fn radians<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[309],
  },
  {
    /* [59] */
    /* fn reflect<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[431],
  },
  {
    /* [60] */
    /* fn refract<N : num>(vec<N, f32>, vec<N, f32>, f32) -> vec<N, f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[430],
  },
  {
    /* [61] */
    /* fn reverseBits<T : iu32>(T) -> T */
    /* fn reverseBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[315],
  },
  {
    /* [62] */
    /* fn round(f32) -> f32 */
    /* fn round<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[317],
  },
  {
    /* [63] */
    /* 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 */ &kOverloads[257],
  },
  {
    /* [64] */
    /* fn sign(f32) -> f32 */
    /* fn sign<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[321],
  },
  {
    /* [65] */
    /* fn sin(f32) -> f32 */
    /* fn sin<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[323],
  },
  {
    /* [66] */
    /* fn sinh(f32) -> f32 */
    /* fn sinh<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[325],
  },
  {
    /* [67] */
    /* fn smoothstep(f32, f32, f32) -> f32 */
    /* fn smoothstep<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[327],
  },
  {
    /* [68] */
    /* fn smoothStep(f32, f32, f32) -> f32 */
    /* fn smoothStep<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[329],
  },
  {
    /* [69] */
    /* fn sqrt(f32) -> f32 */
    /* fn sqrt<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[331],
  },
  {
    /* [70] */
    /* fn step(f32, f32) -> f32 */
    /* fn step<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[333],
  },
  {
    /* [71] */
    /* fn storageBarrier() */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[429],
  },
  {
    /* [72] */
    /* fn tan(f32) -> f32 */
    /* fn tan<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[337],
  },
  {
    /* [73] */
    /* fn tanh(f32) -> f32 */
    /* fn tanh<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[339],
  },
  {
    /* [74] */
    /* fn transpose<M : num, N : num>(mat<M, N, f32>) -> mat<N, M, f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[428],
  },
  {
    /* [75] */
    /* fn trunc(f32) -> f32 */
    /* fn trunc<N : num>(vec<N, f32>) -> vec<N, f32> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[343],
  },
  {
    /* [76] */
    /* fn unpack2x16float(u32) -> vec2<f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[427],
  },
  {
    /* [77] */
    /* fn unpack2x16snorm(u32) -> vec2<f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[409],
  },
  {
    /* [78] */
    /* fn unpack2x16unorm(u32) -> vec2<f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[425],
  },
  {
    /* [79] */
    /* fn unpack4x8snorm(u32) -> vec4<f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[424],
  },
  {
    /* [80] */
    /* fn unpack4x8unorm(u32) -> vec4<f32> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[423],
  },
  {
    /* [81] */
    /* fn workgroupBarrier() */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[422],
  },
  {
    /* [82] */
    /* fn textureDimensions<T : fiu32>(texture: texture_1d<T>) -> i32 */
    /* fn textureDimensions<T : fiu32>(texture: texture_1d<T>, level: i32) -> i32 */
    /* fn textureDimensions<T : fiu32>(texture: texture_2d<T>) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_2d<T>, level: i32) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_2d_array<T>) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_2d_array<T>, level: i32) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_3d<T>) -> vec3<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_3d<T>, level: i32) -> vec3<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_cube<T>) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_cube<T>, level: i32) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_cube_array<T>) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_cube_array<T>, level: i32) -> vec2<i32> */
    /* fn textureDimensions<T : fiu32>(texture: texture_multisampled_2d<T>) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_2d) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_2d, level: i32) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_2d_array) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_2d_array, level: i32) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_cube) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_cube, level: i32) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_cube_array) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_cube_array, level: i32) -> vec2<i32> */
    /* fn textureDimensions(texture: texture_depth_multisampled_2d) -> vec2<i32> */
    /* fn textureDimensions<F : texel_format, A : write_only>(texture: texture_storage_1d<F, A>) -> i32 */
    /* fn textureDimensions<F : texel_format, A : write_only>(texture: texture_storage_2d<F, A>) -> vec2<i32> */
    /* fn textureDimensions<F : texel_format, A : write_only>(texture: texture_storage_2d_array<F, A>) -> vec2<i32> */
    /* fn textureDimensions<F : texel_format, A : write_only>(texture: texture_storage_3d<F, A>) -> vec3<i32> */
    /* fn textureDimensions(texture: texture_external) -> vec2<i32> */
    /* num overloads */ 27,
    /* overloads */ &kOverloads[0],
  },
  {
    /* [83] */
    /* fn textureGather<T : fiu32>(component: i32, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T> */
    /* fn textureGather<T : fiu32>(component: i32, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, offset: vec2<i32>) -> vec4<T> */
    /* fn textureGather<T : fiu32>(component: i32, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: i32) -> vec4<T> */
    /* fn textureGather<T : fiu32>(component: i32, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: i32, offset: vec2<i32>) -> vec4<T> */
    /* fn textureGather<T : fiu32>(component: i32, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T> */
    /* fn textureGather<T : fiu32>(component: i32, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: i32) -> 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>, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGather(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32) -> vec4<f32> */
    /* fn textureGather(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> vec4<f32> */
    /* fn textureGather(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: i32) -> vec4<f32> */
    /* num overloads */ 12,
    /* overloads */ &kOverloads[71],
  },
  {
    /* [84] */
    /* 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, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGatherCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32) -> vec4<f32> */
    /* fn textureGatherCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32> */
    /* fn textureGatherCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> vec4<f32> */
    /* num overloads */ 6,
    /* overloads */ &kOverloads[157],
  },
  {
    /* [85] */
    /* fn textureNumLayers<T : fiu32>(texture: texture_2d_array<T>) -> i32 */
    /* fn textureNumLayers<T : fiu32>(texture: texture_cube_array<T>) -> i32 */
    /* fn textureNumLayers(texture: texture_depth_2d_array) -> i32 */
    /* fn textureNumLayers(texture: texture_depth_cube_array) -> i32 */
    /* fn textureNumLayers<F : texel_format, A : write_only>(texture: texture_storage_2d_array<F, A>) -> i32 */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[205],
  },
  {
    /* [86] */
    /* fn textureNumLevels<T : fiu32>(texture: texture_1d<T>) -> i32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_2d<T>) -> i32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_2d_array<T>) -> i32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_3d<T>) -> i32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_cube<T>) -> i32 */
    /* fn textureNumLevels<T : fiu32>(texture: texture_cube_array<T>) -> i32 */
    /* fn textureNumLevels(texture: texture_depth_2d) -> i32 */
    /* fn textureNumLevels(texture: texture_depth_2d_array) -> i32 */
    /* fn textureNumLevels(texture: texture_depth_cube) -> i32 */
    /* fn textureNumLevels(texture: texture_depth_cube_array) -> i32 */
    /* num overloads */ 10,
    /* overloads */ &kOverloads[105],
  },
  {
    /* [87] */
    /* fn textureNumSamples<T : fiu32>(texture: texture_multisampled_2d<T>) -> i32 */
    /* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> i32 */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[367],
  },
  {
    /* [88] */
    /* 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>, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSample(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32) -> vec4<f32> */
    /* fn textureSample(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, 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>, offset: vec3<i32>) -> vec4<f32> */
    /* fn textureSample(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32> */
    /* fn textureSample(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32) -> 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>, offset: vec2<i32>) -> f32 */
    /* fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32) -> f32 */
    /* fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, offset: vec2<i32>) -> f32 */
    /* fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> f32 */
    /* fn textureSample(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: i32) -> f32 */
    /* num overloads */ 15,
    /* overloads */ &kOverloads[27],
  },
  {
    /* [89] */
    /* 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, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, bias: f32) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, bias: f32, 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, offset: vec3<i32>) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32> */
    /* fn textureSampleBias(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32, bias: f32) -> vec4<f32> */
    /* num overloads */ 8,
    /* overloads */ &kOverloads[133],
  },
  {
    /* [90] */
    /* 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, offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32) -> f32 */
    /* fn textureSampleCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32, offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
    /* fn textureSampleCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> f32 */
    /* num overloads */ 6,
    /* overloads */ &kOverloads[169],
  },
  {
    /* [91] */
    /* 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, offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompareLevel(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32) -> f32 */
    /* fn textureSampleCompareLevel(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: i32, depth_ref: f32, offset: vec2<i32>) -> f32 */
    /* fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
    /* fn textureSampleCompareLevel(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> f32 */
    /* num overloads */ 6,
    /* overloads */ &kOverloads[163],
  },
  {
    /* [92] */
    /* 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>, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleGrad(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32> */
    /* fn textureSampleGrad(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, ddx: vec2<f32>, ddy: vec2<f32>, 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>, 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(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> */
    /* num overloads */ 8,
    /* overloads */ &kOverloads[141],
  },
  {
    /* [93] */
    /* 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, offset: vec2<i32>) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: i32, level: f32, 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, offset: vec3<i32>) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: i32, level: f32) -> vec4<f32> */
    /* fn textureSampleLevel(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: i32) -> f32 */
    /* fn textureSampleLevel(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: i32, offset: vec2<i32>) -> f32 */
    /* fn textureSampleLevel(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, level: i32) -> f32 */
    /* fn textureSampleLevel(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: i32, level: i32, offset: vec2<i32>) -> f32 */
    /* fn textureSampleLevel(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: i32) -> f32 */
    /* fn textureSampleLevel(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: i32, level: i32) -> f32 */
    /* fn textureSampleLevel(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
    /* num overloads */ 15,
    /* overloads */ &kOverloads[42],
  },
  {
    /* [94] */
    /* fn textureStore(texture: texture_storage_1d<f32_texel_format, write>, coords: i32, value: vec4<f32>) */
    /* fn textureStore(texture: texture_storage_2d<f32_texel_format, write>, coords: vec2<i32>, value: vec4<f32>) */
    /* fn textureStore(texture: texture_storage_2d_array<f32_texel_format, write>, coords: vec2<i32>, array_index: i32, value: vec4<f32>) */
    /* fn textureStore(texture: texture_storage_3d<f32_texel_format, write>, coords: vec3<i32>, value: vec4<f32>) */
    /* fn textureStore(texture: texture_storage_1d<i32_texel_format, write>, coords: i32, value: vec4<i32>) */
    /* fn textureStore(texture: texture_storage_2d<i32_texel_format, write>, coords: vec2<i32>, value: vec4<i32>) */
    /* fn textureStore(texture: texture_storage_2d_array<i32_texel_format, write>, coords: vec2<i32>, array_index: i32, value: vec4<i32>) */
    /* fn textureStore(texture: texture_storage_3d<i32_texel_format, write>, coords: vec3<i32>, value: vec4<i32>) */
    /* fn textureStore(texture: texture_storage_1d<u32_texel_format, write>, coords: i32, value: vec4<u32>) */
    /* fn textureStore(texture: texture_storage_2d<u32_texel_format, write>, coords: vec2<i32>, value: vec4<u32>) */
    /* fn textureStore(texture: texture_storage_2d_array<u32_texel_format, write>, coords: vec2<i32>, array_index: i32, value: vec4<u32>) */
    /* fn textureStore(texture: texture_storage_3d<u32_texel_format, write>, coords: vec3<i32>, value: vec4<u32>) */
    /* num overloads */ 12,
    /* overloads */ &kOverloads[83],
  },
  {
    /* [95] */
    /* fn textureLoad<T : fiu32>(texture: texture_1d<T>, coords: i32, level: i32) -> vec4<T> */
    /* fn textureLoad<T : fiu32>(texture: texture_2d<T>, coords: vec2<i32>, level: i32) -> vec4<T> */
    /* fn textureLoad<T : fiu32>(texture: texture_2d_array<T>, coords: vec2<i32>, array_index: i32, level: i32) -> vec4<T> */
    /* fn textureLoad<T : fiu32>(texture: texture_3d<T>, coords: vec3<i32>, level: i32) -> vec4<T> */
    /* fn textureLoad<T : fiu32>(texture: texture_multisampled_2d<T>, coords: vec2<i32>, sample_index: i32) -> vec4<T> */
    /* fn textureLoad(texture: texture_depth_2d, coords: vec2<i32>, level: i32) -> f32 */
    /* fn textureLoad(texture: texture_depth_2d_array, coords: vec2<i32>, array_index: i32, level: i32) -> f32 */
    /* fn textureLoad(texture: texture_depth_multisampled_2d, coords: vec2<i32>, sample_index: i32) -> f32 */
    /* fn textureLoad(texture: texture_external, coords: vec2<i32>) -> vec4<f32> */
    /* num overloads */ 9,
    /* overloads */ &kOverloads[115],
  },
  {
    /* [96] */
    /* fn atomicLoad<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[418],
  },
  {
    /* [97] */
    /* fn atomicStore<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[417],
  },
  {
    /* [98] */
    /* fn atomicAdd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[416],
  },
  {
    /* [99] */
    /* fn atomicSub<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[415],
  },
  {
    /* [100] */
    /* fn atomicMax<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[414],
  },
  {
    /* [101] */
    /* fn atomicMin<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[413],
  },
  {
    /* [102] */
    /* fn atomicAnd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[412],
  },
  {
    /* [103] */
    /* fn atomicOr<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[411],
  },
  {
    /* [104] */
    /* fn atomicXor<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[410],
  },
  {
    /* [105] */
    /* fn atomicExchange<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[426],
  },
  {
    /* [106] */
    /* fn atomicCompareExchangeWeak<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> vec2<T> */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[444],
  },
};

constexpr IntrinsicInfo kUnaryOperators[] = {
  {
    /* [0] */
    /* op !(bool) -> bool */
    /* op !<N : num>(vec<N, bool>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[269],
  },
  {
    /* [1] */
    /* op ~<T : iu32>(T) -> T */
    /* op ~<T : iu32, N : num>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[403],
  },
  {
    /* [2] */
    /* op -<T : fi32>(T) -> T */
    /* op -<T : fi32, N : num>(vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[401],
  },
};
constexpr uint8_t kUnaryOperatorNot = 0;
constexpr uint8_t kUnaryOperatorComplement = 1;
constexpr uint8_t kUnaryOperatorMinus = 2;

constexpr IntrinsicInfo kBinaryOperators[] = {
  {
    /* [0] */
    /* op +<T : fiu32>(T, T) -> T */
    /* op +<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op +<T : fiu32, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op +<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* op +<N : num, M : num>(mat<N, M, f32>, mat<N, M, f32>) -> mat<N, M, f32> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[220],
  },
  {
    /* [1] */
    /* op -<T : fiu32>(T, T) -> T */
    /* op -<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op -<T : fiu32, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op -<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* op -<N : num, M : num>(mat<N, M, f32>, mat<N, M, f32>) -> mat<N, M, f32> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[215],
  },
  {
    /* [2] */
    /* op *<T : fiu32>(T, T) -> T */
    /* op *<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op *<T : fiu32, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op *<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* op *<N : num, M : num>(f32, mat<N, M, f32>) -> mat<N, M, f32> */
    /* op *<N : num, M : num>(mat<N, M, f32>, f32) -> mat<N, M, f32> */
    /* op *<C : num, R : num>(mat<C, R, f32>, vec<C, f32>) -> vec<R, f32> */
    /* op *<C : num, R : num>(vec<R, f32>, mat<C, R, f32>) -> vec<C, f32> */
    /* op *<K : num, C : num, R : num>(mat<K, R, f32>, mat<C, K, f32>) -> mat<C, R, f32> */
    /* num overloads */ 9,
    /* overloads */ &kOverloads[124],
  },
  {
    /* [3] */
    /* op /<T : fiu32>(T, T) -> T */
    /* op /<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op /<T : fiu32, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op /<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ &kOverloads[243],
  },
  {
    /* [4] */
    /* op %<T : fiu32>(T, T) -> T */
    /* op %<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* op %<T : fiu32, N : num>(vec<N, T>, T) -> vec<N, T> */
    /* op %<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ &kOverloads[239],
  },
  {
    /* [5] */
    /* op ^<T : iu32>(T, T) -> T */
    /* op ^<T : iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[389],
  },
  {
    /* [6] */
    /* op &(bool, bool) -> bool */
    /* op &<N : num>(vec<N, bool>, vec<N, bool>) -> vec<N, bool> */
    /* op &<T : iu32>(T, T) -> T */
    /* op &<T : iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ &kOverloads[235],
  },
  {
    /* [7] */
    /* op |(bool, bool) -> bool */
    /* op |<N : num>(vec<N, bool>, vec<N, bool>) -> vec<N, bool> */
    /* op |<T : iu32>(T, T) -> T */
    /* op |<T : iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
    /* num overloads */ 4,
    /* overloads */ &kOverloads[247],
  },
  {
    /* [8] */
    /* op &&(bool, bool) -> bool */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[419],
  },
  {
    /* [9] */
    /* op ||(bool, bool) -> bool */
    /* num overloads */ 1,
    /* overloads */ &kOverloads[420],
  },
  {
    /* [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 */ &kOverloads[373],
  },
  {
    /* [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 */ &kOverloads[355],
  },
  {
    /* [12] */
    /* op <<T : fiu32>(T, T) -> bool */
    /* op <<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[353],
  },
  {
    /* [13] */
    /* op ><T : fiu32>(T, T) -> bool */
    /* op ><T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[351],
  },
  {
    /* [14] */
    /* op <=<T : fiu32>(T, T) -> bool */
    /* op <=<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[349],
  },
  {
    /* [15] */
    /* op >=<T : fiu32>(T, T) -> bool */
    /* op >=<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[407],
  },
  {
    /* [16] */
    /* op <<<T : iu32>(T, u32) -> T */
    /* op <<<T : iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[345],
  },
  {
    /* [17] */
    /* op >><T : iu32>(T, u32) -> T */
    /* op >><T : iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
    /* num overloads */ 2,
    /* overloads */ &kOverloads[341],
  },
};
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 */ &kOverloads[251],
  },
  {
    /* [1] */
    /* ctor u32() -> u32 */
    /* ctor u32(u32) -> u32 */
    /* conv u32<T : scalar_no_u32>(T) -> u32 */
    /* num overloads */ 3,
    /* overloads */ &kOverloads[260],
  },
  {
    /* [2] */
    /* ctor f32() -> f32 */
    /* ctor f32(f32) -> f32 */
    /* conv f32<T : scalar_no_f32>(T) -> f32 */
    /* num overloads */ 3,
    /* overloads */ &kOverloads[263],
  },
  {
    /* [3] */
    /* ctor bool() -> bool */
    /* ctor bool(bool) -> bool */
    /* conv bool<T : scalar_no_bool>(T) -> bool */
    /* num overloads */ 3,
    /* overloads */ &kOverloads[254],
  },
  {
    /* [4] */
    /* ctor vec2<T : 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 : 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 */ 8,
    /* overloads */ &kOverloads[149],
  },
  {
    /* [5] */
    /* ctor vec3<T : 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 : 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 */ 10,
    /* overloads */ &kOverloads[95],
  },
  {
    /* [6] */
    /* ctor vec4<T : 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 : 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 */ 14,
    /* overloads */ &kOverloads[57],
  },
  {
    /* [7] */
    /* ctor mat2x2() -> mat2x2<f32> */
    /* ctor mat2x2<f32>(mat2x2<f32>) -> mat2x2<f32> */
    /* ctor mat2x2<T : f32>(T) -> mat2x2<T> */
    /* ctor mat2x2<T : f32>(T, T, T, T) -> mat2x2<T> */
    /* ctor mat2x2<T : f32>(vec2<T>, vec2<T>) -> mat2x2<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[190],
  },
  {
    /* [8] */
    /* ctor mat2x3() -> mat2x3<f32> */
    /* ctor mat2x3<f32>(mat2x3<f32>) -> mat2x3<f32> */
    /* ctor mat2x3<T : f32>(T) -> mat2x3<T> */
    /* ctor mat2x3<T : f32>(T, T, T, T, T, T) -> mat2x3<T> */
    /* ctor mat2x3<T : f32>(vec3<T>, vec3<T>) -> mat2x3<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[175],
  },
  {
    /* [9] */
    /* ctor mat2x4() -> mat2x4<f32> */
    /* ctor mat2x4<f32>(mat2x4<f32>) -> mat2x4<f32> */
    /* ctor mat2x4<T : f32>(T) -> mat2x4<T> */
    /* ctor mat2x4<T : f32>(T, T, T, T, T, T, T, T) -> mat2x4<T> */
    /* ctor mat2x4<T : f32>(vec4<T>, vec4<T>) -> mat2x4<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[200],
  },
  {
    /* [10] */
    /* ctor mat3x2() -> mat3x2<f32> */
    /* ctor mat3x2<f32>(mat3x2<f32>) -> mat3x2<f32> */
    /* ctor mat3x2<T : f32>(T) -> mat3x2<T> */
    /* ctor mat3x2<T : f32>(T, T, T, T, T, T) -> mat3x2<T> */
    /* ctor mat3x2<T : f32>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[195],
  },
  {
    /* [11] */
    /* ctor mat3x3() -> mat3x3<f32> */
    /* ctor mat3x3<f32>(mat3x3<f32>) -> mat3x3<f32> */
    /* ctor mat3x3<T : f32>(T) -> mat3x3<T> */
    /* ctor mat3x3<T : f32>(T, T, T, T, T, T, T, T, T) -> mat3x3<T> */
    /* ctor mat3x3<T : f32>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[230],
  },
  {
    /* [12] */
    /* ctor mat3x4() -> mat3x4<f32> */
    /* ctor mat3x4<f32>(mat3x4<f32>) -> mat3x4<f32> */
    /* ctor mat3x4<T : f32>(T) -> mat3x4<T> */
    /* ctor mat3x4<T : f32>(T, T, T, T, T, T, T, T, T, T, T, T) -> mat3x4<T> */
    /* ctor mat3x4<T : f32>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[180],
  },
  {
    /* [13] */
    /* ctor mat4x2() -> mat4x2<f32> */
    /* ctor mat4x2<f32>(mat4x2<f32>) -> mat4x2<f32> */
    /* ctor mat4x2<T : f32>(T) -> mat4x2<T> */
    /* ctor mat4x2<T : f32>(T, T, T, T, T, T, T, T) -> mat4x2<T> */
    /* ctor mat4x2<T : f32>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[185],
  },
  {
    /* [14] */
    /* ctor mat4x3() -> mat4x3<f32> */
    /* ctor mat4x3<f32>(mat4x3<f32>) -> mat4x3<f32> */
    /* ctor mat4x3<T : f32>(T) -> mat4x3<T> */
    /* ctor mat4x3<T : f32>(T, T, T, T, T, T, T, T, T, T, T, T) -> mat4x3<T> */
    /* ctor mat4x3<T : f32>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[210],
  },
  {
    /* [15] */
    /* ctor mat4x4() -> mat4x4<f32> */
    /* ctor mat4x4<f32>(mat4x4<f32>) -> mat4x4<f32> */
    /* ctor mat4x4<T : f32>(T) -> mat4x4<T> */
    /* ctor mat4x4<T : f32>(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) -> mat4x4<T> */
    /* ctor mat4x4<T : f32>(vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T> */
    /* num overloads */ 5,
    /* overloads */ &kOverloads[225],
  },
};

// clang-format on