src/intrinsic_table.inl

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

const sem::Type* Ptr::Match(MatchState& state, const sem::Type* ty) const {
  Number S = Number::invalid;
  const sem::Type* T = nullptr;
  Number A = Number::invalid;
  if (!match_ptr(ty, S, T, A)) {
    return nullptr;
  }
  S = state.Num(S);
  if (!S.IsValid()) {
    return nullptr;
  }
  T = state.Type(T);
  if (T == nullptr) {
    return nullptr;
  }
  A = state.Num(A);
  if (!A.IsValid()) {
    return nullptr;
  }
  return build_ptr(state, S, T, A);
}

std::string Ptr::String(MatchState& state) const {
  const std::string S = state.NumName();
  const std::string T = state.TypeName();
  const std::string A = state.NumName();
  return "ptr<" + S + ", " + T + ", " + A + ">";
}

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

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

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

/// TypeMatcher for 'type array'
/// @see src/intrinsics.def:79: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:80: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:81: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:82: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:83: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:84: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:85: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:86: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:87: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:88: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:89: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:90: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:91: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:92:6
class TextureDepthCubeArray : public TypeMatcher {
 public:
  /// Checks whether the given type matches the matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param type the type to match
  /// @returns the canonicalized type on match, otherwise nullptr
  const sem::Type* Match(MatchState& state,
                         const sem::Type* type) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// TypeMatcher for 'match fiu32'
/// @see src/intrinsics.def:111: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:112: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:113: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:124: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:126: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:128: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:131: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 function_private_workgroup'
/// @see src/intrinsics.def:133:7
class FunctionPrivateWorkgroup : public NumberMatcher {
 public:
  /// Checks whether the given number matches the enum matcher rules.
  /// Match may close open types and numbers in state.
  /// @param state the MatchState
  /// @param number the enum value as a Number
  /// @return true if the enum value matches the set
  Number Match(MatchState& state, Number number) const override;
  /// @param state the MatchState
  /// @return a string representation of the matcher.
  std::string String(MatchState& state) const override;
};

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

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

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

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

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

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

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

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

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

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

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

/// EnumMatcher for 'match read'
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(static_cast<uint32_t>(Access::kRead));
  }
  return Number::invalid;
}

std::string Read::String(MatchState&) const {
  return "read";
}

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

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

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

/// Matchers holds type and number matchers
class Matchers {
 private:
  OpenTypeMatcher open_type_0_{0};
  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_;
  Atomic Atomic_;
  Array Array_;
  Sampler Sampler_;
  SamplerComparison SamplerComparison_;
  Texture1D Texture1D_;
  Texture2D Texture2D_;
  Texture2DArray Texture2DArray_;
  Texture3D Texture3D_;
  TextureCube TextureCube_;
  TextureCubeArray TextureCubeArray_;
  TextureMultisampled2D TextureMultisampled2D_;
  TextureDepth2D TextureDepth2D_;
  TextureDepth2DArray TextureDepth2DArray_;
  TextureDepthCube TextureDepthCube_;
  TextureDepthCubeArray TextureDepthCubeArray_;
  TextureDepthMultisampled2D TextureDepthMultisampled2D_;
  TextureStorage1D TextureStorage1D_;
  TextureStorage2D TextureStorage2D_;
  TextureStorage2DArray TextureStorage2DArray_;
  TextureStorage3D TextureStorage3D_;
  TextureExternal TextureExternal_;
  ModfResult ModfResult_;
  ModfResultVec ModfResultVec_;
  FrexpResult FrexpResult_;
  FrexpResultVec FrexpResultVec_;
  Fiu32 Fiu32_;
  Iu32 Iu32_;
  Scalar Scalar_;
  F32TexelFormat F32TexelFormat_;
  I32TexelFormat I32TexelFormat_;
  U32TexelFormat U32TexelFormat_;
  ReadOrWrite ReadOrWrite_;
  FunctionPrivateWorkgroup FunctionPrivateWorkgroup_;
  WorkgroupOrStorage WorkgroupOrStorage_;
  Storage Storage_;
  Write Write_;
  Read Read_;
  ReadWrite ReadWrite_;

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

  /// The open-types, types, and type matchers
  TypeMatcher const* const type[39] = {
    /* [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] */ &Atomic_,
    /* [12] */ &Array_,
    /* [13] */ &Sampler_,
    /* [14] */ &SamplerComparison_,
    /* [15] */ &Texture1D_,
    /* [16] */ &Texture2D_,
    /* [17] */ &Texture2DArray_,
    /* [18] */ &Texture3D_,
    /* [19] */ &TextureCube_,
    /* [20] */ &TextureCubeArray_,
    /* [21] */ &TextureMultisampled2D_,
    /* [22] */ &TextureDepth2D_,
    /* [23] */ &TextureDepth2DArray_,
    /* [24] */ &TextureDepthCube_,
    /* [25] */ &TextureDepthCubeArray_,
    /* [26] */ &TextureDepthMultisampled2D_,
    /* [27] */ &TextureStorage1D_,
    /* [28] */ &TextureStorage2D_,
    /* [29] */ &TextureStorage2DArray_,
    /* [30] */ &TextureStorage3D_,
    /* [31] */ &TextureExternal_,
    /* [32] */ &ModfResult_,
    /* [33] */ &ModfResultVec_,
    /* [34] */ &FrexpResult_,
    /* [35] */ &FrexpResultVec_,
    /* [36] */ &Fiu32_,
    /* [37] */ &Iu32_,
    /* [38] */ &Scalar_,
  };

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

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

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

// 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[167],
  },
  {
    /* [1] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [2] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [3] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [4] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [5] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [6] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [7] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [8] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [9] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [10] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [11] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [12] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [13] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [14] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [15] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [16] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [17] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [18] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [19] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[167],
  },
  {
    /* [20] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [21] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [22] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [23] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [24] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [25] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[163],
  },
  {
    /* [26] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [27] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [28] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [29] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [30] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [31] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [32] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [33] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [34] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [35] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [36] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [37] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[167],
  },
  {
    /* [38] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [39] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [40] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [41] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [42] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [43] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[169],
  },
  {
    /* [44] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [45] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [46] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [47] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [48] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [49] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[167],
  },
  {
    /* [50] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [51] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [52] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [53] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [54] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [55] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [56] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [57] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [58] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [59] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [60] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [61] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [62] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [63] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [64] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [65] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [66] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[180],
  },
  {
    /* [67] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [68] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [69] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [70] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [71] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[180],
  },
  {
    /* [72] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [73] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [74] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [75] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [76] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [77] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [78] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [79] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [80] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [81] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[163],
  },
  {
    /* [82] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [83] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [84] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [85] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [86] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [87] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [88] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [89] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [90] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [91] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [92] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [93] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [94] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [95] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [96] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [97] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [98] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [99] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [100] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [101] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[169],
  },
  {
    /* [102] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [103] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [104] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [105] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [106] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[180],
  },
  {
    /* [107] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [108] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [109] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [110] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [111] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[167],
  },
  {
    /* [112] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [113] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [114] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [115] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [116] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[167],
  },
  {
    /* [117] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [118] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [119] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [120] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [121] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [122] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [123] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [124] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [125] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [126] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[169],
  },
  {
    /* [127] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [128] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [129] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [130] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [131] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[163],
  },
  {
    /* [132] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [133] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [134] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [135] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [136] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [137] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [138] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [139] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [140] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [141] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[157],
  },
  {
    /* [142] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [143] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [144] */
    /* usage */ ParameterUsage::kDdx,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [145] */
    /* usage */ ParameterUsage::kDdy,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [146] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[169],
  },
  {
    /* [147] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [148] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [149] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [150] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [151] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [152] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [153] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [154] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [155] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [156] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [157] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [158] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [159] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [160] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [161] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[167],
  },
  {
    /* [162] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [163] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [164] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [165] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [166] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[163],
  },
  {
    /* [167] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [168] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [169] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [170] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [171] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[169],
  },
  {
    /* [172] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [173] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [174] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [175] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[180],
  },
  {
    /* [176] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [177] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [178] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [179] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [180] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [181] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [182] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [183] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[159],
  },
  {
    /* [184] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [185] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [186] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [187] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[163],
  },
  {
    /* [188] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [189] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [190] */
    /* usage */ ParameterUsage::kBias,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [191] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [192] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[184],
  },
  {
    /* [193] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [194] */
    /* usage */ ParameterUsage::kDepthRef,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [195] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[163],
  },
  {
    /* [196] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [197] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [198] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [199] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[98],
  },
  {
    /* [200] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [201] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [202] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[143],
  },
  {
    /* [203] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[182],
  },
  {
    /* [204] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [205] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [206] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [207] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [208] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [209] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [210] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [211] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[157],
  },
  {
    /* [212] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [213] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [214] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[7],
  },
  {
    /* [215] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[110],
  },
  {
    /* [216] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[133],
  },
  {
    /* [217] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [218] */
    /* usage */ ParameterUsage::kValue,
    /* matcher indices */ &kMatcherIndices[139],
  },
  {
    /* [219] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[147],
  },
  {
    /* [220] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [221] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [222] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [223] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[183],
  },
  {
    /* [224] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [225] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [226] */
    /* usage */ ParameterUsage::kLevel,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [227] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[163],
  },
  {
    /* [228] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [229] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[131],
  },
  {
    /* [230] */
    /* usage */ ParameterUsage::kOffset,
    /* matcher indices */ &kMatcherIndices[137],
  },
  {
    /* [231] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[167],
  },
  {
    /* [232] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [233] */
    /* usage */ ParameterUsage::kCoords,
    /* matcher indices */ &kMatcherIndices[141],
  },
  {
    /* [234] */
    /* usage */ ParameterUsage::kArrayIndex,
    /* matcher indices */ &kMatcherIndices[6],
  },
  {
    /* [235] */
    /* usage */ ParameterUsage::kTexture,
    /* matcher indices */ &kMatcherIndices[169],
  },
  {
    /* [236] */
    /* usage */ ParameterUsage::kSampler,
    /* matcher indices */ &kMatcherIndices[179],
  },
  {
    /* [237] */
    /* usage */