dawn-cmake/src/intrinsic_table.inl

7856 lines
233 KiB
Plaintext
Raw Normal View History

// 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/intrinsic_table.inl.tmpl
// and the intrinsic defintion file:
// src/intrinsics.def
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// clang-format off
/// TypeMatcher for 'type bool'
/// @see src/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/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/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/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/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/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/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 vec'
/// @see src/intrinsics.def:75: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/intrinsics.def:76: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/intrinsics.def:77:37
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();
std::stringstream ss;
ss << "ptr<" << T << ">";
return ss.str();
}
/// TypeMatcher for 'type array'
/// @see src/intrinsics.def:78: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/intrinsics.def:79: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/intrinsics.def:80: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/intrinsics.def:81: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/intrinsics.def:82: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/intrinsics.def:83: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/intrinsics.def:84: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/intrinsics.def:85: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/intrinsics.def:86: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/intrinsics.def:87: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/intrinsics.def:88: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/intrinsics.def:89: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/intrinsics.def:90: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/intrinsics.def:91: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_storage_1d'
/// @see src/intrinsics.def:92: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/intrinsics.def:93: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/intrinsics.def:94: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/intrinsics.def:95: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/intrinsics.def:96: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 'match fiu32'
/// @see src/intrinsics.def:104: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 iu32'
/// @see src/intrinsics.def:105: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/intrinsics.def:106: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";
}
/// EnumMatcher for 'match f32_texel_format'
/// @see src/intrinsics.def:117: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/intrinsics.def:119: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/intrinsics.def:121: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 read_or_write'
/// @see src/intrinsics.def:124:7
class ReadOrWrite : 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 ReadOrWrite::Match(MatchState&, Number number) const {
switch (static_cast<Access>(number.Value())) {
case Access::kRead:
case Access::kWrite:
return number;
default:
return Number::invalid;
}
}
std::string ReadOrWrite::String(MatchState&) const {
return "read or write";
}
/// 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(Access::kWrite);
}
return Number::invalid;
}
std::string Write::String(MatchState&) const {
return "write";
}
/// EnumMatcher for 'match read'
class Read : 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 Read::Match(MatchState&, Number number) const {
if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kRead)) {
return Number(Access::kRead);
}
return Number::invalid;
}
std::string Read::String(MatchState&) const {
return "read";
}
/// Matchers holds type and number matchers
class Matchers {
private:
OpenTypeMatcher open_type_0_{0};
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_;
Vec Vec_;
Mat Mat_;
Ptr Ptr_;
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_;
TextureStorage1D TextureStorage1D_;
TextureStorage2D TextureStorage2D_;
TextureStorage2DArray TextureStorage2DArray_;
TextureStorage3D TextureStorage3D_;
TextureExternal TextureExternal_;
Fiu32 Fiu32_;
Iu32 Iu32_;
Scalar Scalar_;
F32TexelFormat F32TexelFormat_;
I32TexelFormat I32TexelFormat_;
U32TexelFormat U32TexelFormat_;
ReadOrWrite ReadOrWrite_;
Write Write_;
Read Read_;
public:
/// Constructor
Matchers();
/// Destructor
~Matchers();
/// The open-types, types, and type matchers
TypeMatcher const* const type[33] = {
/* [0] */ &open_type_0_,
/* [1] */ &Bool_,
/* [2] */ &F32_,
/* [3] */ &I32_,
/* [4] */ &U32_,
/* [5] */ &Vec2_,
/* [6] */ &Vec3_,
/* [7] */ &Vec4_,
/* [8] */ &Vec_,
/* [9] */ &Mat_,
/* [10] */ &Ptr_,
/* [11] */ &Array_,
/* [12] */ &Sampler_,
/* [13] */ &SamplerComparison_,
/* [14] */ &Texture1D_,
/* [15] */ &Texture2D_,
/* [16] */ &Texture2DArray_,
/* [17] */ &Texture3D_,
/* [18] */ &TextureCube_,
/* [19] */ &TextureCubeArray_,
/* [20] */ &TextureMultisampled2D_,
/* [21] */ &TextureDepth2D_,
/* [22] */ &TextureDepth2DArray_,
/* [23] */ &TextureDepthCube_,
/* [24] */ &TextureDepthCubeArray_,
/* [25] */ &TextureStorage1D_,
/* [26] */ &TextureStorage2D_,
/* [27] */ &TextureStorage2DArray_,
/* [28] */ &TextureStorage3D_,
/* [29] */ &TextureExternal_,
/* [30] */ &Fiu32_,
/* [31] */ &Iu32_,
/* [32] */ &Scalar_,
};
/// The open-numbers, and number matchers
NumberMatcher const* const number[9] = {
/* [0] */ &open_number_0_,
/* [1] */ &open_number_1_,
/* [2] */ &open_number_2_,
/* [3] */ &F32TexelFormat_,
/* [4] */ &I32TexelFormat_,
/* [5] */ &U32TexelFormat_,
/* [6] */ &ReadOrWrite_,
/* [7] */ &Write_,
/* [8] */ &Read_,
};
};
Matchers::Matchers() = default;
Matchers::~Matchers() = default;
constexpr MatcherIndex kMatcherIndices[] = {
/* [0] */ 10,
/* [1] */ 1,
/* [2] */ 8,
/* [3] */ 0,
/* [4] */ 0,
/* [5] */ 2,
/* [6] */ 10,
/* [7] */ 1,
/* [8] */ 8,
/* [9] */ 0,
/* [10] */ 2,
/* [11] */ 2,
/* [12] */ 9,
/* [13] */ 1,
/* [14] */ 0,
/* [15] */ 2,
/* [16] */ 10,
/* [17] */ 0,
/* [18] */ 0,
/* [19] */ 1,
/* [20] */ 10,
/* [21] */ 0,
/* [22] */ 2,
/* [23] */ 1,
/* [24] */ 9,
/* [25] */ 0,
/* [26] */ 0,
/* [27] */ 2,
/* [28] */ 9,
/* [29] */ 0,
/* [30] */ 1,
/* [31] */ 2,
/* [32] */ 8,
/* [33] */ 0,
/* [34] */ 1,
/* [35] */ 28,
/* [36] */ 5,
/* [37] */ 8,
/* [38] */ 26,
/* [39] */ 0,
/* [40] */ 1,
/* [41] */ 25,
/* [42] */ 0,
/* [43] */ 1,
/* [44] */ 27,
/* [45] */ 5,
/* [46] */ 8,
/* [47] */ 26,
/* [48] */ 5,
/* [49] */ 8,
/* [50] */ 25,
/* [51] */ 5,
/* [52] */ 8,
/* [53] */ 28,
/* [54] */ 4,
/* [55] */ 8,
/* [56] */ 27,
/* [57] */ 4,
/* [58] */ 8,
/* [59] */ 26,
/* [60] */ 4,
/* [61] */ 8,
/* [62] */ 25,
/* [63] */ 4,
/* [64] */ 8,
/* [65] */ 27,
/* [66] */ 0,
/* [67] */ 1,
/* [68] */ 28,
/* [69] */ 3,
/* [70] */ 8,
/* [71] */ 27,
/* [72] */ 3,
/* [73] */ 8,
/* [74] */ 26,
/* [75] */ 3,
/* [76] */ 8,
/* [77] */ 25,
/* [78] */ 3,
/* [79] */ 8,
/* [80] */ 28,
/* [81] */ 5,
/* [82] */ 7,
/* [83] */ 2,
/* [84] */ 28,
/* [85] */ 0,
/* [86] */ 1,
/* [87] */ 27,
/* [88] */ 5,
/* [89] */ 7,
/* [90] */ 3,
/* [91] */ 26,
/* [92] */ 5,
/* [93] */ 7,
/* [94] */ 4,
/* [95] */ 25,
/* [96] */ 5,
/* [97] */ 7,
/* [98] */ 0,
/* [99] */ 28,
/* [100] */ 4,
/* [101] */ 7,
/* [102] */ 27,
/* [103] */ 4,
/* [104] */ 7,
/* [105] */ 26,
/* [106] */ 4,
/* [107] */ 7,
/* [108] */ 25,
/* [109] */ 4,
/* [110] */ 7,
/* [111] */ 28,
/* [112] */ 3,
/* [113] */ 7,
/* [114] */ 27,
/* [115] */ 3,
/* [116] */ 7,
/* [117] */ 25,
/* [118] */ 3,
/* [119] */ 7,
/* [120] */ 26,
/* [121] */ 3,
/* [122] */ 7,
/* [123] */ 6,
/* [124] */ 2,
/* [125] */ 5,
/* [126] */ 3,
/* [127] */ 5,
/* [128] */ 2,
/* [129] */ 6,
/* [130] */ 3,
/* [131] */ 19,
/* [132] */ 2,
/* [133] */ 18,
/* [134] */ 2,
/* [135] */ 17,
/* [136] */ 2,
/* [137] */ 14,
/* [138] */ 0,
/* [139] */ 15,
/* [140] */ 0,
/* [141] */ 16,
/* [142] */ 2,
/* [143] */ 16,
/* [144] */ 0,
/* [145] */ 17,
/* [146] */ 0,
/* [147] */ 15,
/* [148] */ 2,
/* [149] */ 20,
/* [150] */ 0,
/* [151] */ 18,
/* [152] */ 0,
/* [153] */ 19,
/* [154] */ 0,
/* [155] */ 11,
/* [156] */ 0,
/* [157] */ 14,
/* [158] */ 2,
/* [159] */ 22,
/* [160] */ 12,
/* [161] */ 21,
/* [162] */ 23,
/* [163] */ 24,
/* [164] */ 29,
/* [165] */ 13,
};
// 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::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [1] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [2] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [3] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [4] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [5] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [6] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [7] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [8] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [9] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [10] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [11] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [12] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [13] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[131],
},
{
/* [14] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [15] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [16] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [17] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [18] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [19] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [20] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [21] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [22] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [23] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [24] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [25] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [26] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [27] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [28] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [29] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [30] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [31] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [32] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[165],
},
{
/* [33] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [34] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [35] */
/* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [36] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [37] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [38] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [39] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [40] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [41] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [42] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [43] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [44] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [45] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [46] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [47] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [48] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [49] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [50] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [51] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [52] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [53] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [54] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [55] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [56] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [57] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [58] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [59] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [60] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [61] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [62] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [63] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [64] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [65] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[163],
},
{
/* [66] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [67] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [68] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [69] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [70] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [71] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [72] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [73] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [74] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [75] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [76] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [77] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [78] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [79] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [80] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[131],
},
{
/* [81] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [82] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [83] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [84] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [85] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [86] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[165],
},
{
/* [87] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [88] */
/* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [89] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [90] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [91] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [92] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [93] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [94] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [95] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [96] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[165],
},
{
/* [97] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [98] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [99] */
/* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [100] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [101] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [102] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [103] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [104] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [105] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[131],
},
{
/* [106] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [107] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [108] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [109] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [110] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [111] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [112] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [113] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [114] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [115] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[163],
},
{
/* [116] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[165],
},
{
/* [117] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [118] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [119] */
/* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [120] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [121] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [122] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [123] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [124] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [125] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [126] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [127] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [128] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [129] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [130] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[133],
},
{
/* [131] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [132] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [133] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [134] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [135] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [136] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [137] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [138] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [139] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [140] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [141] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [142] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [143] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [144] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [145] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [146] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [147] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [148] */
/* usage */ ParameterUsage::kDdx,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [149] */
/* usage */ ParameterUsage::kDdy,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [150] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[143],
},
{
/* [151] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [152] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [153] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [154] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[87],
},
{
/* [155] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [156] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [157] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[93],
},
{
/* [158] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[131],
},
{
/* [159] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [160] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [161] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [162] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[102],
},
{
/* [163] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [164] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [165] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[89],
},
{
/* [166] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[162],
},
{
/* [167] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[165],
},
{
/* [168] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [169] */
/* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [170] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [171] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [172] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [173] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [174] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [175] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[165],
},
{
/* [176] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [177] */
/* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [178] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[114],
},
{
/* [179] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [180] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [181] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[82],
},
{
/* [182] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [183] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [184] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [185] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [186] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[133],
},
{
/* [187] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [188] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [189] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [190] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[133],
},
{
/* [191] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [192] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [193] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [194] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [195] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [196] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [197] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [198] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[162],
},
{
/* [199] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [200] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [201] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [202] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[163],
},
{
/* [203] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [204] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [205] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [206] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [207] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [208] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [209] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [210] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[141],
},
{
/* [211] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [212] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [213] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [214] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [215] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [216] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [217] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [218] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [219] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [220] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [221] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [222] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [223] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [224] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [225] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [226] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [227] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [228] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [229] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [230] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [231] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [232] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [233] */
/* usage */ ParameterUsage::kOffset,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [234] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [235] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [236] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [237] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [238] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[135],
},
{
/* [239] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [240] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [241] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [242] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [243] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [244] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[105],
},
{
/* [245] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [246] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[89],
},
{
/* [247] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [248] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [249] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [250] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [251] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [252] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [253] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[164],
},
{
/* [254] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [255] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [256] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[120],
},
{
/* [257] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [258] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[82],
},
{
/* [259] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[111],
},
{
/* [260] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [261] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[82],
},
{
/* [262] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[108],
},
{
/* [263] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [264] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[89],
},
{
/* [265] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[99],
},
{
/* [266] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [267] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[89],
},
{
/* [268] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[95],
},
{
/* [269] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [270] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[93],
},
{
/* [271] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[91],
},
{
/* [272] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [273] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[93],
},
{
/* [274] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [275] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [276] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[1],
},
{
/* [277] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [278] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [279] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[32],
},
{
/* [280] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [281] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [282] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [283] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [284] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [285] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [286] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[80],
},
{
/* [287] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [288] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[93],
},
{
/* [289] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[137],
},
{
/* [290] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [291] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [292] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[139],
},
{
/* [293] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [294] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [295] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[145],
},
{
/* [296] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [297] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [298] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[149],
},
{
/* [299] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [300] */
/* usage */ ParameterUsage::kSampleIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [301] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [302] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [303] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [304] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[162],
},
{
/* [305] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [306] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [307] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [308] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [309] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [310] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [311] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [312] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [313] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[133],
},
{
/* [314] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [315] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [316] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[71],
},
{
/* [317] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [318] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [319] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [320] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [321] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [322] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [323] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [324] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [325] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[164],
},
{
/* [326] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [327] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [328] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[56],
},
{
/* [329] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [330] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [331] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[147],
},
{
/* [332] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [333] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [334] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[157],
},
{
/* [335] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[160],
},
{
/* [336] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [337] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [338] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [339] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [340] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [341] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [342] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [343] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[44],
},
{
/* [344] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [345] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [346] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[117],
},
{
/* [347] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [348] */
/* usage */ ParameterUsage::kValue,
/* matcher indices */ &kMatcherIndices[82],
},
{
/* [349] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [350] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[6],
},
{
/* [351] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [352] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [353] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [354] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [355] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [356] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [357] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [358] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [359] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[164],
},
{
/* [360] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [361] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [362] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [363] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [364] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [365] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [366] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [367] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [368] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [369] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [370] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [371] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [372] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [373] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [374] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[0],
},
{
/* [375] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [376] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[16],
},
{
/* [377] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [378] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [379] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [380] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [381] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [382] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [383] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [384] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[123],
},
{
/* [385] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [386] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [387] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [388] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [389] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[77],
},
{
/* [390] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [391] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[74],
},
{
/* [392] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [393] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[68],
},
{
/* [394] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [395] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[62],
},
{
/* [396] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [397] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[59],
},
{
/* [398] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [399] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[53],
},
{
/* [400] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [401] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [402] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [403] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [404] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [405] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[35],
},
{
/* [406] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[129],
},
{
/* [407] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[50],
},
{
/* [408] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [409] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[47],
},
{
/* [410] */
/* usage */ ParameterUsage::kCoords,
/* matcher indices */ &kMatcherIndices[125],
},
{
/* [411] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[163],
},
{
/* [412] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [413] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[162],
},
{
/* [414] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [415] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [416] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [417] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [418] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [419] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [420] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[20],
},
{
/* [421] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[151],
},
{
/* [422] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [423] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[145],
},
{
/* [424] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [425] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[143],
},
{
/* [426] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [427] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[139],
},
{
/* [428] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [429] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[153],
},
{
/* [430] */
/* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[69],
},
{
/* [431] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[54],
},
{
/* [432] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[137],
},
{
/* [433] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[139],
},
{
/* [434] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[54],
},
{
/* [435] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[143],
},
{
/* [436] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[54],
},
{
/* [437] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[145],
},
{
/* [438] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[54],
},
{
/* [439] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[151],
},
{
/* [440] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[54],
},
{
/* [441] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[153],
},
{
/* [442] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [443] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[149],
},
{
/* [444] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [445] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [446] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [447] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[28],
},
{
/* [448] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[162],
},
{
/* [449] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [450] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[163],
},
{
/* [451] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [452] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[41],
},
{
/* [453] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[38],
},
{
/* [454] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[65],
},
{
/* [455] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[84],
},
{
/* [456] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[164],
},
{
/* [457] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[143],
},
{
/* [458] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[153],
},
{
/* [459] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [460] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[163],
},
{
/* [461] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[65],
},
{
/* [462] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[139],
},
{
/* [463] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[143],
},
{
/* [464] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[145],
},
{
/* [465] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[151],
},
{
/* [466] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[153],
},
{
/* [467] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[161],
},
{
/* [468] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[159],
},
{
/* [469] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[162],
},
{
/* [470] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[163],
},
{
/* [471] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[149],
},
{
/* [472] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [473] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [474] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [475] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [476] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [477] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [478] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [479] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [480] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [481] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [482] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [483] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [484] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [485] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [486] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[82],
},
{
/* [487] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[82],
},
{
/* [488] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [489] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [490] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[127],
},
{
/* [491] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [492] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [493] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [494] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [495] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [496] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [497] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [498] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [499] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [500] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [501] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [502] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [503] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [504] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [505] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [506] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [507] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [508] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [509] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [510] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [511] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [512] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [513] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [514] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [515] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [516] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [517] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [518] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [519] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [520] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [521] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [522] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [523] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [524] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [525] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [526] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [527] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [528] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [529] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [530] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [531] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [532] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [533] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [534] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [535] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[24],
},
{
/* [536] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [537] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
{
/* [538] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [539] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [540] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [541] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [542] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [543] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [544] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [545] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [546] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [547] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [548] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[155],
},
{
/* [549] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[32],
},
{
/* [550] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[32],
},
{
/* [551] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[8],
},
{
/* [552] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[5],
},
{
/* [553] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[2],
},
{
/* [554] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[3],
},
};
constexpr OpenTypeInfo kOpenTypes[] = {
{
/* [0] */
/* name */ "T",
/* matcher index */ 31,
},
{
/* [1] */
/* name */ "T",
/* matcher index */ 30,
},
{
/* [2] */
/* name */ "T",
/* matcher index */ kNoMatcher,
},
{
/* [3] */
/* name */ "T",
/* matcher index */ 32,
},
};
constexpr OpenNumberInfo kOpenNumbers[] = {
{
/* [0] */
/* name */ "M",
/* matcher index */ kNoMatcher,
},
{
/* [1] */
/* name */ "N",
/* matcher index */ kNoMatcher,
},
{
/* [2] */
/* name */ "S",
/* matcher index */ kNoMatcher,
},
{
/* [3] */
/* name */ "A",
/* matcher index */ kNoMatcher,
},
{
/* [4] */
/* name */ "F",
/* matcher index */ kNoMatcher,
},
{
/* [5] */
/* name */ "A",
/* matcher index */ 6,
},
};
constexpr OverloadInfo kOverloads[] = {
{
/* [0] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[432],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [1] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[433],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [2] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[427],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [3] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[435],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [4] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[425],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [5] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[437],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [6] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[423],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [7] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[439],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [8] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[421],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [9] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[441],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [10] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[429],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [11] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[443],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [12] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[444],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [13] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[417],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [14] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[446],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [15] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[415],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [16] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[448],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [17] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[413],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [18] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[450],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [19] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[411],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [20] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[4],
/* parameters */ &kParameters[452],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [21] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[4],
/* parameters */ &kParameters[453],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [22] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[4],
/* parameters */ &kParameters[454],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [23] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[4],
/* parameters */ &kParameters[455],
/* return matcher indices */ &kMatcherIndices[129],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [24] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[456],
/* return matcher indices */ &kMatcherIndices[125],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [25] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[289],
/* return matcher indices */ &kMatcherIndices[97],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [26] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[292],
/* return matcher indices */ &kMatcherIndices[97],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [27] */
/* num parameters */ 4,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[150],
/* return matcher indices */ &kMatcherIndices[97],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [28] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[295],
/* return matcher indices */ &kMatcherIndices[97],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [29] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[298],
/* return matcher indices */ &kMatcherIndices[97],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [30] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[310],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [31] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[182],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [32] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[389],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [33] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[391],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [34] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[316],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [35] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[393],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [36] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[395],
/* return matcher indices */ &kMatcherIndices[89],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [37] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[397],
/* return matcher indices */ &kMatcherIndices[89],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [38] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[328],
/* return matcher indices */ &kMatcherIndices[89],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [39] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[399],
/* return matcher indices */ &kMatcherIndices[89],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [40] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[407],
/* return matcher indices */ &kMatcherIndices[93],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [41] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[409],
/* return matcher indices */ &kMatcherIndices[93],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [42] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[343],
/* return matcher indices */ &kMatcherIndices[93],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [43] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[405],
/* return matcher indices */ &kMatcherIndices[93],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [44] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[359],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [45] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[334],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [46] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[331],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [47] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[230],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [48] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[210],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [49] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[60],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [50] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[238],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [51] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[194],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [52] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[313],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [53] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[158],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [54] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[283],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [55] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[206],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [56] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[218],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [57] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[90],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [58] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[304],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [59] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[202],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [60] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[325],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [61] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[170],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [62] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[55],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [63] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[75],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [64] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[43],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [65] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[214],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [66] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[135],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [67] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[190],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [68] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[105],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [69] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[222],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [70] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[100],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [71] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[110],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [72] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[49],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [73] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[198],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [74] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[65],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [75] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[253],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [76] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[346],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [77] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[256],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [78] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[178],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [79] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[259],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [80] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[262],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [81] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[244],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [82] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[162],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [83] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[265],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [84] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[268],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [85] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[271],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [86] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[154],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [87] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[286],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [88] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[462],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [89] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[463],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [90] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[464],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [91] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[465],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [92] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[466],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [93] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[467],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [94] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[468],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [95] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[469],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [96] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[470],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [97] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[120],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [98] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[25],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [99] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[19],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [100] */
/* num parameters */ 7,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[0],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [101] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[145],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [102] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[37],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [103] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[130],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [104] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[13],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [105] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[226],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [106] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[125],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [107] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[140],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [108] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[7],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [109] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[234],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [110] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[70],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [111] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[186],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [112] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[80],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [113] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[174],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [114] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[85],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [115] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[95],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [116] */
/* num parameters */ 6,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[31],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [117] */
/* num parameters */ 4,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[166],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [118] */
/* num parameters */ 5,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[115],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [119] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[457],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [120] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[458],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [121] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[459],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [122] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[460],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [123] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[4],
/* parameters */ &kParameters[461],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [124] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[387],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [125] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[385],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [126] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[539],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [127] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[538],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [128] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[537],
/* return matcher indices */ &kMatcherIndices[3],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [129] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[536],
/* return matcher indices */ &kMatcherIndices[2],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [130] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[541],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [131] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[540],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [132] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[475],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [133] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[474],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [134] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[381],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [135] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[379],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [136] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[307],
/* return matcher indices */ &kMatcherIndices[3],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [137] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[301],
/* return matcher indices */ &kMatcherIndices[2],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [138] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[534],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [139] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[533],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [140] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[532],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [141] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[531],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [142] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[530],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [143] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[529],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [144] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[528],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [145] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[527],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [146] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[526],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [147] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[525],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [148] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[524],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [149] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[523],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kFragment),
},
{
/* [150] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[522],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [151] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[521],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [152] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[520],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [153] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[519],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [154] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[250],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [155] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[247],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [156] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[518],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [157] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[517],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [158] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[280],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [159] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[241],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [160] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[516],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [161] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[515],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [162] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[2],
/* parameters */ &kParameters[375],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [163] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 3,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[373],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [164] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[514],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [165] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[513],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [166] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[512],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [167] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[511],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [168] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[510],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [169] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[509],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [170] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[357],
/* return matcher indices */ &kMatcherIndices[3],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [171] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[355],
/* return matcher indices */ &kMatcherIndices[2],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [172] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[507],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [173] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[506],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [174] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[505],
/* return matcher indices */ &kMatcherIndices[1],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [175] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[504],
/* return matcher indices */ &kMatcherIndices[32],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [176] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[503],
/* return matcher indices */ &kMatcherIndices[1],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [177] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[502],
/* return matcher indices */ &kMatcherIndices[32],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [178] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[501],
/* return matcher indices */ &kMatcherIndices[1],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [179] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[500],
/* return matcher indices */ &kMatcherIndices[32],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [180] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[499],
/* return matcher indices */ &kMatcherIndices[1],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [181] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[498],
/* return matcher indices */ &kMatcherIndices[32],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [182] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[371],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [183] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[369],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [184] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[497],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [185] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[496],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [186] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[495],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [187] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[494],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [188] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[493],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [189] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[492],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [190] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[543],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [191] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[542],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [192] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[353],
/* return matcher indices */ &kMatcherIndices[3],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [193] */
/* num parameters */ 2,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[351],
/* return matcher indices */ &kMatcherIndices[2],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [194] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[337],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [195] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[340],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [196] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[2],
/* parameters */ &kParameters[419],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [197] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 3,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[349],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [198] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[319],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [199] */
/* num parameters */ 3,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[322],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [200] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[545],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [201] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[544],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [202] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[547],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [203] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[546],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [204] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[445],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [205] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[442],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [206] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[451],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [207] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[449],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [208] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[473],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [209] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[472],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [210] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[401],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [211] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[403],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [212] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[552],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [213] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[551],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [214] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[485],
/* return matcher indices */ &kMatcherIndices[3],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [215] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[0],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[484],
/* return matcher indices */ &kMatcherIndices[2],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [216] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[483],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [217] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[482],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [218] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[3],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[274],
/* return matcher indices */ &kMatcherIndices[3],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [219] */
/* num parameters */ 3,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[3],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[277],
/* return matcher indices */ &kMatcherIndices[2],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [220] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[481],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [221] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[480],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [222] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[479],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [223] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[478],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [224] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[477],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [225] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[476],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [226] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[365],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [227] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[367],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [228] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[361],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [229] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[363],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [230] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[554],
/* return matcher indices */ &kMatcherIndices[3],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [231] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[553],
/* return matcher indices */ &kMatcherIndices[2],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [232] */
/* num parameters */ 0,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[555],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kCompute),
},
{
/* [233] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[486],
/* return matcher indices */ &kMatcherIndices[54],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [234] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[487],
/* return matcher indices */ &kMatcherIndices[54],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [235] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 2,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[0],
/* parameters */ &kParameters[447],
/* return matcher indices */ &kMatcherIndices[12],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [236] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[488],
/* return matcher indices */ &kMatcherIndices[54],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [237] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[440],
/* return matcher indices */ &kMatcherIndices[127],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [238] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[438],
/* return matcher indices */ &kMatcherIndices[127],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [239] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[436],
/* return matcher indices */ &kMatcherIndices[127],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [240] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[434],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [241] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[431],
/* return matcher indices */ &kMatcherIndices[82],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [242] */
/* num parameters */ 0,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[555],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kCompute),
},
{
/* [243] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[489],
/* return matcher indices */ &kMatcherIndices[54],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [244] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[490],
/* return matcher indices */ &kMatcherIndices[54],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [245] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[491],
/* return matcher indices */ &kMatcherIndices[8],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [246] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[1],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[471],
/* return matcher indices */ &kMatcherIndices[69],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [247] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[377],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [248] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[535],
/* return matcher indices */ &kMatcherIndices[5],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [249] */
/* num parameters */ 2,
/* num open types */ 0,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[383],
/* return matcher indices */ &kMatcherIndices[123],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [250] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[2],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[548],
/* return matcher indices */ &kMatcherIndices[54],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [251] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[549],
/* return matcher indices */ &kMatcherIndices[1],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [252] */
/* num parameters */ 1,
/* num open types */ 0,
/* num open numbers */ 1,
/* open types */ &kOpenTypes[4],
/* open numbers */ &kOpenNumbers[1],
/* parameters */ &kParameters[550],
/* return matcher indices */ &kMatcherIndices[1],
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
{
/* [253] */
/* num parameters */ 1,
/* num open types */ 1,
/* num open numbers */ 0,
/* open types */ &kOpenTypes[2],
/* open numbers */ &kOpenNumbers[6],
/* parameters */ &kParameters[508],
/* return matcher indices */ nullptr,
/* supported_stages */ PipelineStageSet(PipelineStage::kVertex, PipelineStage::kFragment, PipelineStage::kCompute),
},
};
constexpr IntrinsicInfo kIntrinsics[] = {
{
/* [0] */
/* fn abs<T : fiu32>(T) -> T */
/* fn abs<N : num, T : fiu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
/* overloads */ &kOverloads[230],
},
{
/* [1] */
/* fn acos(f32) -> f32 */
/* fn acos<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[212],
},
{
/* [2] */
/* fn all<N : num>(vec<N, bool>) -> bool */
/* num overloads */ 1,
/* overloads */ &kOverloads[252],
},
{
/* [3] */
/* fn any<N : num>(vec<N, bool>) -> bool */
/* num overloads */ 1,
/* overloads */ &kOverloads[251],
},
{
/* [4] */
/* fn arrayLength<T>(array<T>) -> u32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[250],
},
{
/* [5] */
/* fn asin(f32) -> f32 */
/* fn asin<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[202],
},
{
/* [6] */
/* fn atan(f32) -> f32 */
/* fn atan<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[200],
},
{
/* [7] */
/* fn atan2(f32, f32) -> f32 */
/* fn atan2<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[124],
},
{
/* [8] */
/* fn ceil(f32) -> f32 */
/* fn ceil<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[190],
},
{
/* [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[136],
},
{
/* [10] */
/* fn cos(f32) -> f32 */
/* fn cos<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[130],
},
{
/* [11] */
/* fn cosh(f32) -> f32 */
/* fn cosh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[126],
},
{
/* [12] */
/* fn countOneBits<T : iu32>(T) -> T */
/* fn countOneBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
/* overloads */ &kOverloads[128],
},
{
/* [13] */
/* fn cross(vec3<f32>, vec3<f32>) -> vec3<f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[249],
},
{
/* [14] */
/* fn determinant<N : num>(mat<N, N, f32>) -> f32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[248],
},
{
/* [15] */
/* fn distance(f32, f32) -> f32 */
/* fn distance<N : num>(vec<N, f32>, vec<N, f32>) -> f32 */
/* num overloads */ 2,
/* overloads */ &kOverloads[134],
},
{
/* [16] */
/* fn dot<N : num>(vec<N, f32>, vec<N, f32>) -> f32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[247],
},
{
/* [17] */
/* fn dpdx(f32) -> f32 */
/* fn dpdx<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[138],
},
{
/* [18] */
/* fn dpdxCoarse(f32) -> f32 */
/* fn dpdxCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[140],
},
{
/* [19] */
/* fn dpdxFine(f32) -> f32 */
/* fn dpdxFine<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[142],
},
{
/* [20] */
/* fn dpdy(f32) -> f32 */
/* fn dpdy<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[144],
},
{
/* [21] */
/* fn dpdyCoarse(f32) -> f32 */
/* fn dpdyCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[146],
},
{
/* [22] */
/* fn dpdyFine(f32) -> f32 */
/* fn dpdyFine<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[148],
},
{
/* [23] */
/* fn exp(f32) -> f32 */
/* fn exp<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[150],
},
{
/* [24] */
/* fn exp2(f32) -> f32 */
/* fn exp2<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[152],
},
{
/* [25] */
/* fn faceForward(f32, f32, f32) -> f32 */
/* fn faceForward<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[154],
},
{
/* [26] */
/* fn floor(f32) -> f32 */
/* fn floor<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[156],
},
{
/* [27] */
/* 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[158],
},
{
/* [28] */
/* fn fract(f32) -> f32 */
/* fn fract<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[160],
},
{
/* [29] */
/* fn frexp<T : iu32, S : storage_class, A : access>(f32, ptr<S, T, A>) -> f32 */
/* fn frexp<N : num, T : iu32, S : storage_class, A : access>(vec<N, f32>, ptr<S, vec<N, T>, A>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[162],
},
{
/* [30] */
/* fn fwidth(f32) -> f32 */
/* fn fwidth<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[164],
},
{
/* [31] */
/* fn fwidthCoarse(f32) -> f32 */
/* fn fwidthCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[166],
},
{
/* [32] */
/* fn fwidthFine(f32) -> f32 */
/* fn fwidthFine<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[168],
},
{
/* [33] */
/* fn ignore<T>(T) */
/* num overloads */ 1,
/* overloads */ &kOverloads[253],
},
{
/* [34] */
/* fn inverseSqrt(f32) -> f32 */
/* fn inverseSqrt<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[172],
},
{
/* [35] */
/* fn isFinite(f32) -> bool */
/* fn isFinite<N : num>(vec<N, f32>) -> vec<N, bool> */
/* num overloads */ 2,
/* overloads */ &kOverloads[174],
},
{
/* [36] */
/* fn isInf(f32) -> bool */
/* fn isInf<N : num>(vec<N, f32>) -> vec<N, bool> */
/* num overloads */ 2,
/* overloads */ &kOverloads[176],
},
{
/* [37] */
/* fn isNan(f32) -> bool */
/* fn isNan<N : num>(vec<N, f32>) -> vec<N, bool> */
/* num overloads */ 2,
/* overloads */ &kOverloads[178],
},
{
/* [38] */
/* fn isNormal(f32) -> bool */
/* fn isNormal<N : num>(vec<N, f32>) -> vec<N, bool> */
/* num overloads */ 2,
/* overloads */ &kOverloads[180],
},
{
/* [39] */
/* fn ldexp<T : iu32>(f32, T) -> f32 */
/* fn ldexp<N : num, T : iu32>(vec<N, f32>, vec<N, T>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[182],
},
{
/* [40] */
/* fn length(f32) -> f32 */
/* fn length<N : num>(vec<N, f32>) -> f32 */
/* num overloads */ 2,
/* overloads */ &kOverloads[184],
},
{
/* [41] */
/* fn log(f32) -> f32 */
/* fn log<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[186],
},
{
/* [42] */
/* fn log2(f32) -> f32 */
/* fn log2<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[188],
},
{
/* [43] */
/* 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[170],
},
{
/* [44] */
/* 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[192],
},
{
/* [45] */
/* fn mix(f32, f32, f32) -> f32 */
/* fn mix<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[194],
},
{
/* [46] */
/* fn modf<S : storage_class, A : access>(f32, ptr<S, f32, A>) -> f32 */
/* fn modf<N : num, S : storage_class, A : access>(vec<N, f32>, ptr<S, vec<N, f32>, A>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[196],
},
{
/* [47] */
/* fn normalize<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[245],
},
{
/* [48] */
/* fn pack2x16float(vec2<f32>) -> u32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[244],
},
{
/* [49] */
/* fn pack2x16snorm(vec2<f32>) -> u32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[243],
},
{
/* [50] */
/* fn pack2x16unorm(vec2<f32>) -> u32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[236],
},
{
/* [51] */
/* fn pack4x8snorm(vec4<f32>) -> u32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[234],
},
{
/* [52] */
/* fn pack4x8unorm(vec4<f32>) -> u32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[233],
},
{
/* [53] */
/* fn pow(f32, f32) -> f32 */
/* fn pow<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[228],
},
{
/* [54] */
/* fn reflect(f32, f32) -> f32 */
/* fn reflect<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[226],
},
{
/* [55] */
/* fn reverseBits<T : iu32>(T) -> T */
/* fn reverseBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
/* overloads */ &kOverloads[214],
},
{
/* [56] */
/* fn round(f32) -> f32 */
/* fn round<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[216],
},
{
/* [57] */
/* fn select<T : scalar>(T, T, bool) -> T */
/* fn select<N : num, T : scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T> */
/* num overloads */ 2,
/* overloads */ &kOverloads[218],
},
{
/* [58] */
/* fn sign(f32) -> f32 */
/* fn sign<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[220],
},
{
/* [59] */
/* fn sin(f32) -> f32 */
/* fn sin<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[222],
},
{
/* [60] */
/* fn sinh(f32) -> f32 */
/* fn sinh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[224],
},
{
/* [61] */
/* 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[198],
},
{
/* [62] */
/* fn sqrt(f32) -> f32 */
/* fn sqrt<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[132],
},
{
/* [63] */
/* fn step(f32, f32) -> f32 */
/* fn step<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[210],
},
{
/* [64] */
/* fn storageBarrier() */
/* num overloads */ 1,
/* overloads */ &kOverloads[242],
},
{
/* [65] */
/* fn tan(f32) -> f32 */
/* fn tan<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[208],
},
{
/* [66] */
/* fn tanh(f32) -> f32 */
/* fn tanh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[206],
},
{
/* [67] */
/* fn transpose<M : num, N : num>(mat<M, N, f32>) -> mat<N, M, f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[235],
},
{
/* [68] */
/* fn trunc(f32) -> f32 */
/* fn trunc<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
/* overloads */ &kOverloads[204],
},
{
/* [69] */
/* fn unpack2x16float(u32) -> vec2<f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[237],
},
{
/* [70] */
/* fn unpack2x16snorm(u32) -> vec2<f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[238],
},
{
/* [71] */
/* fn unpack2x16unorm(u32) -> vec2<f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[239],
},
{
/* [72] */
/* fn unpack4x8snorm(u32) -> vec4<f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[240],
},
{
/* [73] */
/* fn unpack4x8unorm(u32) -> vec4<f32> */
/* num overloads */ 1,
/* overloads */ &kOverloads[241],
},
{
/* [74] */
/* fn workgroupBarrier() */
/* num overloads */ 1,
/* overloads */ &kOverloads[232],
},
{
/* [75] */
/* fn textureDimensions<T : fiu32>(texture: texture_1d<T>) -> 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>) -> vec3<i32> */
/* fn textureDimensions<T : fiu32>(texture: texture_cube<T>, level: i32) -> vec3<i32> */
/* fn textureDimensions<T : fiu32>(texture: texture_cube_array<T>) -> vec3<i32> */
/* fn textureDimensions<T : fiu32>(texture: texture_cube_array<T>, level: i32) -> vec3<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) -> vec3<i32> */
/* fn textureDimensions(texture: texture_depth_cube, level: i32) -> vec3<i32> */
/* fn textureDimensions(texture: texture_depth_cube_array) -> vec3<i32> */
/* fn textureDimensions(texture: texture_depth_cube_array, level: i32) -> vec3<i32> */
/* fn textureDimensions<F : texel_format, A : read_or_write>(texture: texture_storage_1d<F, A>) -> i32 */
/* fn textureDimensions<F : texel_format, A : read_or_write>(texture: texture_storage_2d<F, A>) -> vec2<i32> */
/* fn textureDimensions<F : texel_format, A : read_or_write>(texture: texture_storage_2d_array<F, A>) -> vec2<i32> */
/* fn textureDimensions<F : texel_format, A : read_or_write>(texture: texture_storage_3d<F, A>) -> vec3<i32> */
/* fn textureDimensions(texture: texture_external) -> vec2<i32> */
/* num overloads */ 25,
/* overloads */ &kOverloads[0],
},
{
/* [76] */
/* 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 : read_or_write>(texture: texture_storage_2d_array<F, A>) -> i32 */
/* num overloads */ 5,
/* overloads */ &kOverloads[119],
},
{
/* [77] */
/* 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 */ 9,
/* overloads */ &kOverloads[88],
},
{
/* [78] */
/* fn textureNumSamples<T : fiu32>(texture: texture_multisampled_2d<T>) -> i32 */
/* num overloads */ 1,
/* overloads */ &kOverloads[246],
},
{
/* [79] */
/* 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 */
/* fn textureSample(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32> */
/* num overloads */ 16,
/* overloads */ &kOverloads[45],
},
{
/* [80] */
/* 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[105],
},
{
/* [81] */
/* 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[113],
},
{
/* [82] */
/* 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[97],
},
{
/* [83] */
/* 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[61],
},
{
/* [84] */
/* 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[76],
},
{
/* [85] */
/* 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_storage_1d<f32_texel_format, read>, coords: i32) -> vec4<f32> */
/* fn textureLoad(texture: texture_storage_2d<f32_texel_format, read>, coords: vec2<i32>) -> vec4<f32> */
/* fn textureLoad(texture: texture_storage_2d_array<f32_texel_format, read>, coords: vec2<i32>, array_index: i32) -> vec4<f32> */
/* fn textureLoad(texture: texture_storage_3d<f32_texel_format, read>, coords: vec3<i32>) -> vec4<f32> */
/* fn textureLoad(texture: texture_storage_1d<i32_texel_format, read>, coords: i32) -> vec4<i32> */
/* fn textureLoad(texture: texture_storage_2d<i32_texel_format, read>, coords: vec2<i32>) -> vec4<i32> */
/* fn textureLoad(texture: texture_storage_2d_array<i32_texel_format, read>, coords: vec2<i32>, array_index: i32) -> vec4<i32> */
/* fn textureLoad(texture: texture_storage_3d<i32_texel_format, read>, coords: vec3<i32>) -> vec4<i32> */
/* fn textureLoad(texture: texture_storage_1d<u32_texel_format, read>, coords: i32) -> vec4<u32> */
/* fn textureLoad(texture: texture_storage_2d<u32_texel_format, read>, coords: vec2<i32>) -> vec4<u32> */
/* fn textureLoad(texture: texture_storage_2d_array<u32_texel_format, read>, coords: vec2<i32>, array_index: i32) -> vec4<u32> */
/* fn textureLoad(texture: texture_storage_3d<u32_texel_format, read>, coords: vec3<i32>) -> vec4<u32> */
/* fn textureLoad(texture: texture_external, coords: vec2<i32>) -> vec4<f32> */
/* num overloads */ 20,
/* overloads */ &kOverloads[25],
},
};
// clang-format on