/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op Definitions                                                             *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_OP_LIST
#undef GET_OP_LIST

spirv::AccessChainOp,
spirv::AddressOfOp,
spirv::AtomicAndOp,
spirv::AtomicCompareExchangeWeakOp,
spirv::AtomicIAddOp,
spirv::AtomicIDecrementOp,
spirv::AtomicIIncrementOp,
spirv::AtomicISubOp,
spirv::AtomicOrOp,
spirv::AtomicSMaxOp,
spirv::AtomicSMinOp,
spirv::AtomicUMaxOp,
spirv::AtomicUMinOp,
spirv::AtomicXorOp,
spirv::BitCountOp,
spirv::BitFieldInsertOp,
spirv::BitFieldSExtractOp,
spirv::BitFieldUExtractOp,
spirv::BitReverseOp,
spirv::BitcastOp,
spirv::BitwiseAndOp,
spirv::BitwiseOrOp,
spirv::BitwiseXorOp,
spirv::BranchConditionalOp,
spirv::BranchOp,
spirv::CompositeConstructOp,
spirv::CompositeExtractOp,
spirv::CompositeInsertOp,
spirv::ConstantOp,
spirv::ControlBarrierOp,
spirv::ConvertFToSOp,
spirv::ConvertFToUOp,
spirv::ConvertSToFOp,
spirv::ConvertUToFOp,
spirv::CooperativeMatrixLengthNVOp,
spirv::CooperativeMatrixLoadNVOp,
spirv::CooperativeMatrixMulAddNVOp,
spirv::CooperativeMatrixStoreNVOp,
spirv::CopyMemoryOp,
spirv::EntryPointOp,
spirv::ExecutionModeOp,
spirv::FAddOp,
spirv::FConvertOp,
spirv::FDivOp,
spirv::FModOp,
spirv::FMulOp,
spirv::FNegateOp,
spirv::FOrdEqualOp,
spirv::FOrdGreaterThanEqualOp,
spirv::FOrdGreaterThanOp,
spirv::FOrdLessThanEqualOp,
spirv::FOrdLessThanOp,
spirv::FOrdNotEqualOp,
spirv::FRemOp,
spirv::FSubOp,
spirv::FUnordEqualOp,
spirv::FUnordGreaterThanEqualOp,
spirv::FUnordGreaterThanOp,
spirv::FUnordLessThanEqualOp,
spirv::FUnordLessThanOp,
spirv::FUnordNotEqualOp,
spirv::FuncOp,
spirv::FunctionCallOp,
spirv::GLSLCeilOp,
spirv::GLSLCosOp,
spirv::GLSLExpOp,
spirv::GLSLFAbsOp,
spirv::GLSLFMaxOp,
spirv::GLSLFMinOp,
spirv::GLSLFSignOp,
spirv::GLSLFloorOp,
spirv::GLSLInverseSqrtOp,
spirv::GLSLLogOp,
spirv::GLSLSAbsOp,
spirv::GLSLSMaxOp,
spirv::GLSLSMinOp,
spirv::GLSLSSignOp,
spirv::GLSLSinOp,
spirv::GLSLSqrtOp,
spirv::GLSLTanOp,
spirv::GLSLTanhOp,
spirv::GlobalVariableOp,
spirv::GroupNonUniformBallotOp,
spirv::GroupNonUniformElectOp,
spirv::GroupNonUniformFAddOp,
spirv::GroupNonUniformFMaxOp,
spirv::GroupNonUniformFMinOp,
spirv::GroupNonUniformFMulOp,
spirv::GroupNonUniformIAddOp,
spirv::GroupNonUniformIMulOp,
spirv::GroupNonUniformSMaxOp,
spirv::GroupNonUniformSMinOp,
spirv::GroupNonUniformUMaxOp,
spirv::GroupNonUniformUMinOp,
spirv::IAddOp,
spirv::IEqualOp,
spirv::IMulOp,
spirv::INotEqualOp,
spirv::ISubOp,
spirv::LoadOp,
spirv::LogicalAndOp,
spirv::LogicalEqualOp,
spirv::LogicalNotEqualOp,
spirv::LogicalNotOp,
spirv::LogicalOrOp,
spirv::LoopOp,
spirv::MatrixTimesMatrixOp,
spirv::MatrixTimesScalarOp,
spirv::MemoryBarrierOp,
spirv::MergeOp,
spirv::ModuleEndOp,
spirv::ModuleOp,
spirv::NotOp,
spirv::ReferenceOfOp,
spirv::ReturnOp,
spirv::ReturnValueOp,
spirv::SConvertOp,
spirv::SDivOp,
spirv::SGreaterThanEqualOp,
spirv::SGreaterThanOp,
spirv::SLessThanEqualOp,
spirv::SLessThanOp,
spirv::SModOp,
spirv::SNegateOp,
spirv::SRemOp,
spirv::SelectOp,
spirv::SelectionOp,
spirv::ShiftLeftLogicalOp,
spirv::ShiftRightArithmeticOp,
spirv::ShiftRightLogicalOp,
spirv::SpecConstantOp,
spirv::StoreOp,
spirv::SubgroupBallotKHROp,
spirv::TransposeOp,
spirv::UConvertOp,
spirv::UDivOp,
spirv::UGreaterThanEqualOp,
spirv::UGreaterThanOp,
spirv::ULessThanEqualOp,
spirv::ULessThanOp,
spirv::UModOp,
spirv::UndefOp,
spirv::UnreachableOp,
spirv::VariableOp
#endif  // GET_OP_LIST

#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES


//===----------------------------------------------------------------------===//
// spirv::AccessChainOp definitions
//===----------------------------------------------------------------------===//

AccessChainOpAdaptor::AccessChainOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AccessChainOpAdaptor::AccessChainOpAdaptor(AccessChainOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AccessChainOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange AccessChainOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AccessChainOpAdaptor::base_ptr() {
  return *getODSOperands(0).begin();
}

::mlir::ValueRange AccessChainOpAdaptor::indices() {
  return getODSOperands(1);
}

::mlir::LogicalResult AccessChainOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef AccessChainOp::getOperationName() {
  return "spv.AccessChain";
}

std::pair<unsigned, unsigned> AccessChainOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range AccessChainOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AccessChainOp::base_ptr() {
  return *getODSOperands(0).begin();
}

::mlir::Operation::operand_range AccessChainOp::indices() {
  return getODSOperands(1);
}

::mlir::MutableOperandRange AccessChainOp::base_ptrMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AccessChainOp::indicesMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AccessChainOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AccessChainOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AccessChainOp::component_ptr() {
  return *getODSResults(0).begin();
}



void AccessChainOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type component_ptr, ::mlir::Value base_ptr, ::mlir::ValueRange indices) {
  odsState.addOperands(base_ptr);
  odsState.addOperands(indices);
  odsState.addTypes(component_ptr);
}

void AccessChainOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value base_ptr, ::mlir::ValueRange indices) {
  odsState.addOperands(base_ptr);
  odsState.addOperands(indices);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AccessChainOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AccessChainOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAccessChainOp(parser, result);
}

void AccessChainOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult AccessChainOp::verify() {
  if (failed(AccessChainOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}











void AccessChainOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::AddressOfOp definitions
//===----------------------------------------------------------------------===//

AddressOfOpAdaptor::AddressOfOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AddressOfOpAdaptor::AddressOfOpAdaptor(AddressOfOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AddressOfOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AddressOfOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::FlatSymbolRefAttr AddressOfOpAdaptor::variable() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::FlatSymbolRefAttr attr = odsAttrs.get("variable").cast<::mlir::FlatSymbolRefAttr>();
  return attr;
}

::mlir::LogicalResult AddressOfOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_variable = odsAttrs.get("variable");
  if (!tblgen_variable) return emitError(loc, "'spv._address_of' op ""requires attribute 'variable'");
    if (!((tblgen_variable.isa<::mlir::FlatSymbolRefAttr>()))) return emitError(loc, "'spv._address_of' op ""attribute 'variable' failed to satisfy constraint: flat symbol reference attribute");
  }
  return success();
}

::llvm::StringRef AddressOfOp::getOperationName() {
  return "spv._address_of";
}

std::pair<unsigned, unsigned> AddressOfOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AddressOfOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> AddressOfOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AddressOfOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AddressOfOp::pointer() {
  return *getODSResults(0).begin();
}

::mlir::FlatSymbolRefAttr AddressOfOp::variableAttr() {
  return this->getAttr("variable").cast<::mlir::FlatSymbolRefAttr>();
}

::llvm::StringRef AddressOfOp::variable() {
  auto attr = variableAttr();
  return attr.getValue();
}

void AddressOfOp::variableAttr(::mlir::FlatSymbolRefAttr attr) {
  this->getOperation()->setAttr("variable", attr);
}



void AddressOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type pointer, ::mlir::FlatSymbolRefAttr variable) {
  odsState.addAttribute("variable", variable);
  odsState.addTypes(pointer);
}

void AddressOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::FlatSymbolRefAttr variable) {
  odsState.addAttribute("variable", variable);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AddressOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type pointer, ::llvm::StringRef variable) {
  odsState.addAttribute("variable", odsBuilder.getSymbolRefAttr(variable));
  odsState.addTypes(pointer);
}

void AddressOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::llvm::StringRef variable) {
  odsState.addAttribute("variable", odsBuilder.getSymbolRefAttr(variable));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AddressOfOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult AddressOfOp::verify() {
  if (failed(AddressOfOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
  return ::verify(*this);
}









::mlir::ParseResult AddressOfOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type pointerRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> pointerTypes(pointerRawTypes);

  ::mlir::FlatSymbolRefAttr variableAttr;
  if (parser.parseAttribute(variableAttr, parser.getBuilder().getType<::mlir::NoneType>(), "variable", result.attributes))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(pointerRawTypes[0]))
    return failure();
  result.addTypes(pointerTypes);
  return success();
}

void AddressOfOp::print(OpAsmPrinter &p) {
  p << "spv._address_of";
  p << " ";
  p.printAttributeWithoutType(variableAttr());
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"variable"});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(pointer().getType());
}

void AddressOfOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::AtomicAndOp definitions
//===----------------------------------------------------------------------===//

AtomicAndOpAdaptor::AtomicAndOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicAndOpAdaptor::AtomicAndOpAdaptor(AtomicAndOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicAndOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicAndOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicAndOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicAndOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicAndOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicAndOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicAndOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicAnd' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicAnd' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicAnd' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicAnd' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicAndOp::getOperationName() {
  return "spv.AtomicAnd";
}

std::pair<unsigned, unsigned> AtomicAndOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicAndOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicAndOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicAndOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicAndOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicAndOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicAndOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicAndOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicAndOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicAndOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicAndOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicAndOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicAndOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicAndOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicAndOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicAndOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicAndOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicAndOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicAndOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicAndOp::verify() {
  if (failed(AtomicAndOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicCompareExchangeWeakOp definitions
//===----------------------------------------------------------------------===//

AtomicCompareExchangeWeakOpAdaptor::AtomicCompareExchangeWeakOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicCompareExchangeWeakOpAdaptor::AtomicCompareExchangeWeakOpAdaptor(AtomicCompareExchangeWeakOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicCompareExchangeWeakOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicCompareExchangeWeakOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicCompareExchangeWeakOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicCompareExchangeWeakOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::Value AtomicCompareExchangeWeakOpAdaptor::comparator() {
  return *getODSOperands(2).begin();
}

::mlir::IntegerAttr AtomicCompareExchangeWeakOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicCompareExchangeWeakOpAdaptor::equal_semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("equal_semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicCompareExchangeWeakOpAdaptor::unequal_semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("unequal_semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicCompareExchangeWeakOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicCompareExchangeWeak' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicCompareExchangeWeak' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_equal_semantics = odsAttrs.get("equal_semantics");
  if (!tblgen_equal_semantics) return emitError(loc, "'spv.AtomicCompareExchangeWeak' op ""requires attribute 'equal_semantics'");
    if (!((((tblgen_equal_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_equal_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_equal_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicCompareExchangeWeak' op ""attribute 'equal_semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  {
  auto tblgen_unequal_semantics = odsAttrs.get("unequal_semantics");
  if (!tblgen_unequal_semantics) return emitError(loc, "'spv.AtomicCompareExchangeWeak' op ""requires attribute 'unequal_semantics'");
    if (!((((tblgen_unequal_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_unequal_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_unequal_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicCompareExchangeWeak' op ""attribute 'unequal_semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicCompareExchangeWeakOp::getOperationName() {
  return "spv.AtomicCompareExchangeWeak";
}

std::pair<unsigned, unsigned> AtomicCompareExchangeWeakOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicCompareExchangeWeakOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicCompareExchangeWeakOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicCompareExchangeWeakOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::Value AtomicCompareExchangeWeakOp::comparator() {
  return *getODSOperands(2).begin();
}

::mlir::MutableOperandRange AtomicCompareExchangeWeakOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicCompareExchangeWeakOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicCompareExchangeWeakOp::comparatorMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicCompareExchangeWeakOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicCompareExchangeWeakOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicCompareExchangeWeakOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicCompareExchangeWeakOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicCompareExchangeWeakOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicCompareExchangeWeakOp::equal_semanticsAttr() {
  return this->getAttr("equal_semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicCompareExchangeWeakOp::equal_semantics() {
  auto attr = equal_semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

::mlir::IntegerAttr AtomicCompareExchangeWeakOp::unequal_semanticsAttr() {
  return this->getAttr("unequal_semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicCompareExchangeWeakOp::unequal_semantics() {
  auto attr = unequal_semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicCompareExchangeWeakOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicCompareExchangeWeakOp::equal_semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("equal_semantics", attr);
}

void AtomicCompareExchangeWeakOp::unequal_semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("unequal_semantics", attr);
}

void AtomicCompareExchangeWeakOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr equal_semantics, ::mlir::IntegerAttr unequal_semantics, ::mlir::Value value, ::mlir::Value comparator) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addOperands(comparator);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("equal_semantics", equal_semantics);
  odsState.addAttribute("unequal_semantics", unequal_semantics);
  odsState.addTypes(result);
}

void AtomicCompareExchangeWeakOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr equal_semantics, ::mlir::IntegerAttr unequal_semantics, ::mlir::Value value, ::mlir::Value comparator) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addOperands(comparator);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("equal_semantics", equal_semantics);
  odsState.addAttribute("unequal_semantics", unequal_semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicCompareExchangeWeakOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics equal_semantics, ::mlir::spirv::MemorySemantics unequal_semantics, ::mlir::Value value, ::mlir::Value comparator) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addOperands(comparator);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("equal_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(equal_semantics)));
  odsState.addAttribute("unequal_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(unequal_semantics)));
  odsState.addTypes(result);
}

void AtomicCompareExchangeWeakOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics equal_semantics, ::mlir::spirv::MemorySemantics unequal_semantics, ::mlir::Value value, ::mlir::Value comparator) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addOperands(comparator);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("equal_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(equal_semantics)));
  odsState.addAttribute("unequal_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(unequal_semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicCompareExchangeWeakOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 3u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicCompareExchangeWeakOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicCompareExchangeWeakOp(parser, result);
}

void AtomicCompareExchangeWeakOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult AtomicCompareExchangeWeakOp::verify() {
  if (failed(AtomicCompareExchangeWeakOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::AtomicIAddOp definitions
//===----------------------------------------------------------------------===//

AtomicIAddOpAdaptor::AtomicIAddOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicIAddOpAdaptor::AtomicIAddOpAdaptor(AtomicIAddOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicIAddOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicIAddOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIAddOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicIAddOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicIAddOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicIAddOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicIAddOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicIAdd' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicIAdd' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicIAdd' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicIAdd' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicIAddOp::getOperationName() {
  return "spv.AtomicIAdd";
}

std::pair<unsigned, unsigned> AtomicIAddOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicIAddOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIAddOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicIAddOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicIAddOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicIAddOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicIAddOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicIAddOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIAddOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicIAddOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicIAddOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicIAddOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicIAddOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicIAddOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicIAddOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicIAddOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicIAddOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicIAddOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicIAddOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicIAddOp::verify() {
  if (failed(AtomicIAddOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicIDecrementOp definitions
//===----------------------------------------------------------------------===//

AtomicIDecrementOpAdaptor::AtomicIDecrementOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicIDecrementOpAdaptor::AtomicIDecrementOpAdaptor(AtomicIDecrementOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicIDecrementOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicIDecrementOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIDecrementOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::IntegerAttr AtomicIDecrementOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicIDecrementOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicIDecrementOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicIDecrement' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicIDecrement' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicIDecrement' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicIDecrement' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicIDecrementOp::getOperationName() {
  return "spv.AtomicIDecrement";
}

std::pair<unsigned, unsigned> AtomicIDecrementOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicIDecrementOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIDecrementOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange AtomicIDecrementOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicIDecrementOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicIDecrementOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIDecrementOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicIDecrementOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicIDecrementOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicIDecrementOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicIDecrementOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicIDecrementOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicIDecrementOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicIDecrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicIDecrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicIDecrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicIDecrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicIDecrementOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicIDecrementOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, false);
}

void AtomicIDecrementOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicIDecrementOp::verify() {
  if (failed(AtomicIDecrementOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicIIncrementOp definitions
//===----------------------------------------------------------------------===//

AtomicIIncrementOpAdaptor::AtomicIIncrementOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicIIncrementOpAdaptor::AtomicIIncrementOpAdaptor(AtomicIIncrementOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicIIncrementOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicIIncrementOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIIncrementOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::IntegerAttr AtomicIIncrementOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicIIncrementOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicIIncrementOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicIIncrement' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicIIncrement' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicIIncrement' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicIIncrement' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicIIncrementOp::getOperationName() {
  return "spv.AtomicIIncrement";
}

std::pair<unsigned, unsigned> AtomicIIncrementOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicIIncrementOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIIncrementOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange AtomicIIncrementOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicIIncrementOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicIIncrementOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicIIncrementOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicIIncrementOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicIIncrementOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicIIncrementOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicIIncrementOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicIIncrementOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicIIncrementOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicIIncrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicIIncrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicIIncrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicIIncrementOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics) {
  odsState.addOperands(pointer);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicIIncrementOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicIIncrementOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, false);
}

void AtomicIIncrementOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicIIncrementOp::verify() {
  if (failed(AtomicIIncrementOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicISubOp definitions
//===----------------------------------------------------------------------===//

AtomicISubOpAdaptor::AtomicISubOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicISubOpAdaptor::AtomicISubOpAdaptor(AtomicISubOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicISubOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicISubOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicISubOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicISubOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicISubOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicISubOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicISubOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicISub' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicISub' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicISub' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicISub' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicISubOp::getOperationName() {
  return "spv.AtomicISub";
}

std::pair<unsigned, unsigned> AtomicISubOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicISubOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicISubOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicISubOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicISubOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicISubOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicISubOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicISubOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicISubOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicISubOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicISubOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicISubOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicISubOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicISubOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicISubOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicISubOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicISubOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicISubOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicISubOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicISubOp::verify() {
  if (failed(AtomicISubOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicOrOp definitions
//===----------------------------------------------------------------------===//

AtomicOrOpAdaptor::AtomicOrOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicOrOpAdaptor::AtomicOrOpAdaptor(AtomicOrOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicOrOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicOrOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicOrOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicOrOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicOrOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicOrOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicOrOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicOr' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicOr' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicOr' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicOr' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicOrOp::getOperationName() {
  return "spv.AtomicOr";
}

std::pair<unsigned, unsigned> AtomicOrOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicOrOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicOrOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicOrOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicOrOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicOrOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicOrOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicOrOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicOrOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicOrOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicOrOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicOrOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicOrOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicOrOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicOrOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicOrOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicOrOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicOrOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicOrOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicOrOp::verify() {
  if (failed(AtomicOrOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicSMaxOp definitions
//===----------------------------------------------------------------------===//

AtomicSMaxOpAdaptor::AtomicSMaxOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicSMaxOpAdaptor::AtomicSMaxOpAdaptor(AtomicSMaxOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicSMaxOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicSMaxOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicSMaxOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicSMaxOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicSMaxOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicSMaxOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicSMaxOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicSMax' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicSMax' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicSMax' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicSMax' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicSMaxOp::getOperationName() {
  return "spv.AtomicSMax";
}

std::pair<unsigned, unsigned> AtomicSMaxOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicSMaxOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicSMaxOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicSMaxOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicSMaxOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicSMaxOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicSMaxOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicSMaxOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicSMaxOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicSMaxOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicSMaxOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicSMaxOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicSMaxOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicSMaxOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicSMaxOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicSMaxOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicSMaxOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicSMaxOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicSMaxOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicSMaxOp::verify() {
  if (failed(AtomicSMaxOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicSMinOp definitions
//===----------------------------------------------------------------------===//

AtomicSMinOpAdaptor::AtomicSMinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicSMinOpAdaptor::AtomicSMinOpAdaptor(AtomicSMinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicSMinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicSMinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicSMinOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicSMinOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicSMinOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicSMinOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicSMinOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicSMin' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicSMin' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicSMin' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicSMin' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicSMinOp::getOperationName() {
  return "spv.AtomicSMin";
}

std::pair<unsigned, unsigned> AtomicSMinOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicSMinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicSMinOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicSMinOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicSMinOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicSMinOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicSMinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicSMinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicSMinOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicSMinOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicSMinOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicSMinOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicSMinOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicSMinOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicSMinOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicSMinOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicSMinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicSMinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicSMinOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicSMinOp::verify() {
  if (failed(AtomicSMinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicUMaxOp definitions
//===----------------------------------------------------------------------===//

AtomicUMaxOpAdaptor::AtomicUMaxOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicUMaxOpAdaptor::AtomicUMaxOpAdaptor(AtomicUMaxOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicUMaxOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicUMaxOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicUMaxOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicUMaxOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicUMaxOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicUMaxOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicUMaxOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicUMax' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicUMax' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicUMax' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicUMax' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicUMaxOp::getOperationName() {
  return "spv.AtomicUMax";
}

std::pair<unsigned, unsigned> AtomicUMaxOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicUMaxOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicUMaxOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicUMaxOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicUMaxOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicUMaxOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicUMaxOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicUMaxOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicUMaxOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicUMaxOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicUMaxOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicUMaxOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicUMaxOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicUMaxOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicUMaxOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicUMaxOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicUMaxOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicUMaxOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicUMaxOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicUMaxOp::verify() {
  if (failed(AtomicUMaxOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicUMinOp definitions
//===----------------------------------------------------------------------===//

AtomicUMinOpAdaptor::AtomicUMinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicUMinOpAdaptor::AtomicUMinOpAdaptor(AtomicUMinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicUMinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicUMinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicUMinOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicUMinOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicUMinOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicUMinOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicUMinOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicUMin' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicUMin' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicUMin' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicUMin' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicUMinOp::getOperationName() {
  return "spv.AtomicUMin";
}

std::pair<unsigned, unsigned> AtomicUMinOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicUMinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicUMinOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicUMinOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicUMinOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicUMinOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicUMinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicUMinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicUMinOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicUMinOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicUMinOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicUMinOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicUMinOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicUMinOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicUMinOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicUMinOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicUMinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicUMinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicUMinOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicUMinOp::verify() {
  if (failed(AtomicUMinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::AtomicXorOp definitions
//===----------------------------------------------------------------------===//

AtomicXorOpAdaptor::AtomicXorOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

AtomicXorOpAdaptor::AtomicXorOpAdaptor(AtomicXorOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> AtomicXorOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange AtomicXorOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicXorOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicXorOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr AtomicXorOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr AtomicXorOpAdaptor::semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult AtomicXorOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.AtomicXor' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicXor' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_semantics = odsAttrs.get("semantics");
  if (!tblgen_semantics) return emitError(loc, "'spv.AtomicXor' op ""requires attribute 'semantics'");
    if (!((((tblgen_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.AtomicXor' op ""attribute 'semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef AtomicXorOp::getOperationName() {
  return "spv.AtomicXor";
}

std::pair<unsigned, unsigned> AtomicXorOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range AtomicXorOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicXorOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value AtomicXorOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange AtomicXorOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange AtomicXorOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> AtomicXorOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range AtomicXorOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value AtomicXorOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr AtomicXorOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope AtomicXorOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr AtomicXorOp::semanticsAttr() {
  return this->getAttr("semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics AtomicXorOp::semantics() {
  auto attr = semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void AtomicXorOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void AtomicXorOp::semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("semantics", attr);
}

void AtomicXorOp::build(OpBuilder &builder, OperationState &state, Value pointer,
        ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
        Value value) {
build(builder, state, value.getType(), pointer, scope, memory, value);
}

void AtomicXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  odsState.addTypes(result);
}

void AtomicXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("semantics", semantics);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  odsState.addTypes(result);
}

void AtomicXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics semantics, ::mlir::Value value) {
  odsState.addOperands(pointer);
  odsState.addOperands(value);
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(semantics)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void AtomicXorOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult AtomicXorOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseAtomicUpdateOp(parser, result, true);
}

void AtomicXorOp::print(::mlir::OpAsmPrinter &p) {
  return ::printAtomicUpdateOp(getOperation(), p);
}

::mlir::LogicalResult AtomicXorOp::verify() {
  if (failed(AtomicXorOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyAtomicUpdateOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::BitCountOp definitions
//===----------------------------------------------------------------------===//

BitCountOpAdaptor::BitCountOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitCountOpAdaptor::BitCountOpAdaptor(BitCountOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitCountOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitCountOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitCountOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult BitCountOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitCountOp::getOperationName() {
  return "spv.BitCount";
}

std::pair<unsigned, unsigned> BitCountOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitCountOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitCountOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange BitCountOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitCountOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitCountOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitCountOp::result() {
  return *getODSResults(0).begin();
}

void BitCountOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void BitCountOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitCountOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void BitCountOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes({operand.getType()});

}

void BitCountOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult BitCountOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseUnaryOp(parser, result);
}

void BitCountOp::print(::mlir::OpAsmPrinter &p) {
  return ::printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult BitCountOp::verify() {
  if (failed(BitCountOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void BitCountOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitFieldInsertOp definitions
//===----------------------------------------------------------------------===//

BitFieldInsertOpAdaptor::BitFieldInsertOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitFieldInsertOpAdaptor::BitFieldInsertOpAdaptor(BitFieldInsertOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitFieldInsertOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitFieldInsertOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldInsertOpAdaptor::base() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitFieldInsertOpAdaptor::insert() {
  return *getODSOperands(1).begin();
}

::mlir::Value BitFieldInsertOpAdaptor::offset() {
  return *getODSOperands(2).begin();
}

::mlir::Value BitFieldInsertOpAdaptor::count() {
  return *getODSOperands(3).begin();
}

::mlir::LogicalResult BitFieldInsertOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitFieldInsertOp::getOperationName() {
  return "spv.BitFieldInsert";
}

std::pair<unsigned, unsigned> BitFieldInsertOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitFieldInsertOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldInsertOp::base() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitFieldInsertOp::insert() {
  return *getODSOperands(1).begin();
}

::mlir::Value BitFieldInsertOp::offset() {
  return *getODSOperands(2).begin();
}

::mlir::Value BitFieldInsertOp::count() {
  return *getODSOperands(3).begin();
}

::mlir::MutableOperandRange BitFieldInsertOp::baseMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitFieldInsertOp::insertMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitFieldInsertOp::offsetMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitFieldInsertOp::countMutable() {
  auto range = getODSOperandIndexAndLength(3);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitFieldInsertOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitFieldInsertOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldInsertOp::result() {
  return *getODSResults(0).begin();
}

void BitFieldInsertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value base, ::mlir::Value insert, ::mlir::Value offset, ::mlir::Value count) {
  odsState.addOperands(base);
  odsState.addOperands(insert);
  odsState.addOperands(offset);
  odsState.addOperands(count);
  odsState.addTypes(result);
}

void BitFieldInsertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value base, ::mlir::Value insert, ::mlir::Value offset, ::mlir::Value count) {
  odsState.addOperands(base);
  odsState.addOperands(insert);
  odsState.addOperands(offset);
  odsState.addOperands(count);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitFieldInsertOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 4u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult BitFieldInsertOp::verify() {
  if (failed(BitFieldInsertOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup3 = getODSOperands(3);
    for (::mlir::Value v : valueGroup3) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  if (!((::llvm::is_splat(::llvm::makeArrayRef({(*this->getODSOperands(0).begin()).getType(), (*this->getODSOperands(1).begin()).getType(), (*this->getODSResults(0).begin()).getType()})))))
    return emitOpError("failed to verify that all of {base, insert, result} have same type");
  return success();
}









::mlir::ParseResult BitFieldInsertOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type baseRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> baseTypes(baseRawTypes);
  ::mlir::Type offsetRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> offsetTypes(offsetRawTypes);
  ::mlir::Type countRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> countTypes(countRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(baseRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(offsetRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(countRawTypes[0]))
    return failure();
  result.addTypes(baseTypes);
  if (parser.resolveOperands(allOperands, ::llvm::concat<const Type>(::llvm::ArrayRef<::mlir::Type>(baseTypes), ::llvm::ArrayRef<::mlir::Type>(baseTypes), ::llvm::ArrayRef<::mlir::Type>(offsetTypes), ::llvm::ArrayRef<::mlir::Type>(countTypes)), allOperandLoc, result.operands))
    return failure();
  return success();
}

void BitFieldInsertOp::print(OpAsmPrinter &p) {
  p << "spv.BitFieldInsert";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(base().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(offset().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(count().getType());
}

void BitFieldInsertOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitFieldSExtractOp definitions
//===----------------------------------------------------------------------===//

BitFieldSExtractOpAdaptor::BitFieldSExtractOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitFieldSExtractOpAdaptor::BitFieldSExtractOpAdaptor(BitFieldSExtractOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitFieldSExtractOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitFieldSExtractOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldSExtractOpAdaptor::base() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitFieldSExtractOpAdaptor::offset() {
  return *getODSOperands(1).begin();
}

::mlir::Value BitFieldSExtractOpAdaptor::count() {
  return *getODSOperands(2).begin();
}

::mlir::LogicalResult BitFieldSExtractOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitFieldSExtractOp::getOperationName() {
  return "spv.BitFieldSExtract";
}

std::pair<unsigned, unsigned> BitFieldSExtractOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitFieldSExtractOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldSExtractOp::base() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitFieldSExtractOp::offset() {
  return *getODSOperands(1).begin();
}

::mlir::Value BitFieldSExtractOp::count() {
  return *getODSOperands(2).begin();
}

::mlir::MutableOperandRange BitFieldSExtractOp::baseMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitFieldSExtractOp::offsetMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitFieldSExtractOp::countMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitFieldSExtractOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitFieldSExtractOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldSExtractOp::result() {
  return *getODSResults(0).begin();
}

void BitFieldSExtractOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value base, ::mlir::Value offset, ::mlir::Value count) {
  odsState.addOperands(base);
  odsState.addOperands(offset);
  odsState.addOperands(count);
  odsState.addTypes(result);
}

void BitFieldSExtractOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value base, ::mlir::Value offset, ::mlir::Value count) {
  odsState.addOperands(base);
  odsState.addOperands(offset);
  odsState.addOperands(count);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitFieldSExtractOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 3u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult BitFieldSExtractOp::verify() {
  if (failed(BitFieldSExtractOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  if (!((::llvm::is_splat(::llvm::makeArrayRef({(*this->getODSOperands(0).begin()).getType(), (*this->getODSResults(0).begin()).getType()})))))
    return emitOpError("failed to verify that all of {base, result} have same type");
  return success();
}









::mlir::ParseResult BitFieldSExtractOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type baseRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> baseTypes(baseRawTypes);
  ::mlir::Type offsetRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> offsetTypes(offsetRawTypes);
  ::mlir::Type countRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> countTypes(countRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(baseRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(offsetRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(countRawTypes[0]))
    return failure();
  result.addTypes(baseTypes);
  if (parser.resolveOperands(allOperands, ::llvm::concat<const Type>(::llvm::ArrayRef<::mlir::Type>(baseTypes), ::llvm::ArrayRef<::mlir::Type>(offsetTypes), ::llvm::ArrayRef<::mlir::Type>(countTypes)), allOperandLoc, result.operands))
    return failure();
  return success();
}

void BitFieldSExtractOp::print(OpAsmPrinter &p) {
  p << "spv.BitFieldSExtract";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(base().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(offset().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(count().getType());
}

void BitFieldSExtractOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitFieldUExtractOp definitions
//===----------------------------------------------------------------------===//

BitFieldUExtractOpAdaptor::BitFieldUExtractOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitFieldUExtractOpAdaptor::BitFieldUExtractOpAdaptor(BitFieldUExtractOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitFieldUExtractOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitFieldUExtractOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldUExtractOpAdaptor::base() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitFieldUExtractOpAdaptor::offset() {
  return *getODSOperands(1).begin();
}

::mlir::Value BitFieldUExtractOpAdaptor::count() {
  return *getODSOperands(2).begin();
}

::mlir::LogicalResult BitFieldUExtractOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitFieldUExtractOp::getOperationName() {
  return "spv.BitFieldUExtract";
}

std::pair<unsigned, unsigned> BitFieldUExtractOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitFieldUExtractOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldUExtractOp::base() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitFieldUExtractOp::offset() {
  return *getODSOperands(1).begin();
}

::mlir::Value BitFieldUExtractOp::count() {
  return *getODSOperands(2).begin();
}

::mlir::MutableOperandRange BitFieldUExtractOp::baseMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitFieldUExtractOp::offsetMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitFieldUExtractOp::countMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitFieldUExtractOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitFieldUExtractOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitFieldUExtractOp::result() {
  return *getODSResults(0).begin();
}

void BitFieldUExtractOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value base, ::mlir::Value offset, ::mlir::Value count) {
  odsState.addOperands(base);
  odsState.addOperands(offset);
  odsState.addOperands(count);
  odsState.addTypes(result);
}

void BitFieldUExtractOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value base, ::mlir::Value offset, ::mlir::Value count) {
  odsState.addOperands(base);
  odsState.addOperands(offset);
  odsState.addOperands(count);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitFieldUExtractOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 3u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult BitFieldUExtractOp::verify() {
  if (failed(BitFieldUExtractOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  if (!((::llvm::is_splat(::llvm::makeArrayRef({(*this->getODSOperands(0).begin()).getType(), (*this->getODSResults(0).begin()).getType()})))))
    return emitOpError("failed to verify that all of {base, result} have same type");
  return success();
}









::mlir::ParseResult BitFieldUExtractOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type baseRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> baseTypes(baseRawTypes);
  ::mlir::Type offsetRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> offsetTypes(offsetRawTypes);
  ::mlir::Type countRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> countTypes(countRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(baseRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(offsetRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(countRawTypes[0]))
    return failure();
  result.addTypes(baseTypes);
  if (parser.resolveOperands(allOperands, ::llvm::concat<const Type>(::llvm::ArrayRef<::mlir::Type>(baseTypes), ::llvm::ArrayRef<::mlir::Type>(offsetTypes), ::llvm::ArrayRef<::mlir::Type>(countTypes)), allOperandLoc, result.operands))
    return failure();
  return success();
}

void BitFieldUExtractOp::print(OpAsmPrinter &p) {
  p << "spv.BitFieldUExtract";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(base().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(offset().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(count().getType());
}

void BitFieldUExtractOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitReverseOp definitions
//===----------------------------------------------------------------------===//

BitReverseOpAdaptor::BitReverseOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitReverseOpAdaptor::BitReverseOpAdaptor(BitReverseOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitReverseOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitReverseOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitReverseOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult BitReverseOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitReverseOp::getOperationName() {
  return "spv.BitReverse";
}

std::pair<unsigned, unsigned> BitReverseOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitReverseOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitReverseOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange BitReverseOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitReverseOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitReverseOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitReverseOp::result() {
  return *getODSResults(0).begin();
}

void BitReverseOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void BitReverseOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitReverseOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void BitReverseOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes({operand.getType()});

}

void BitReverseOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult BitReverseOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseUnaryOp(parser, result);
}

void BitReverseOp::print(::mlir::OpAsmPrinter &p) {
  return ::printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult BitReverseOp::verify() {
  if (failed(BitReverseOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void BitReverseOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitcastOp definitions
//===----------------------------------------------------------------------===//

BitcastOpAdaptor::BitcastOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitcastOpAdaptor::BitcastOpAdaptor(BitcastOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitcastOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitcastOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitcastOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult BitcastOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitcastOp::getOperationName() {
  return "spv.Bitcast";
}

std::pair<unsigned, unsigned> BitcastOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitcastOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitcastOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange BitcastOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitcastOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitcastOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitcastOp::result() {
  return *getODSResults(0).begin();
}

void BitcastOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void BitcastOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitcastOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult BitcastOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void BitcastOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult BitcastOp::verify() {
  if (failed(BitcastOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64())))) || ((v.getType().isSignlessInteger(1)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4)))))) || ((v.getType().isa<::mlir::spirv::PointerType>())))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or 16/32/64-bit float or bool or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64())))) || ((v.getType().isSignlessInteger(1)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4)))))) || ((v.getType().isa<::mlir::spirv::PointerType>())))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or 16/32/64-bit float or bool or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}











void BitcastOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitwiseAndOp definitions
//===----------------------------------------------------------------------===//

BitwiseAndOpAdaptor::BitwiseAndOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitwiseAndOpAdaptor::BitwiseAndOpAdaptor(BitwiseAndOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitwiseAndOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitwiseAndOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseAndOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitwiseAndOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult BitwiseAndOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitwiseAndOp::getOperationName() {
  return "spv.BitwiseAnd";
}

std::pair<unsigned, unsigned> BitwiseAndOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitwiseAndOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseAndOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitwiseAndOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange BitwiseAndOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitwiseAndOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitwiseAndOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitwiseAndOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseAndOp::result() {
  return *getODSResults(0).begin();
}

void BitwiseAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void BitwiseAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitwiseAndOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void BitwiseAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void BitwiseAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult BitwiseAndOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void BitwiseAndOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult BitwiseAndOp::verify() {
  if (failed(BitwiseAndOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void BitwiseAndOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitwiseOrOp definitions
//===----------------------------------------------------------------------===//

BitwiseOrOpAdaptor::BitwiseOrOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitwiseOrOpAdaptor::BitwiseOrOpAdaptor(BitwiseOrOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitwiseOrOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitwiseOrOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseOrOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitwiseOrOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult BitwiseOrOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitwiseOrOp::getOperationName() {
  return "spv.BitwiseOr";
}

std::pair<unsigned, unsigned> BitwiseOrOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitwiseOrOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseOrOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitwiseOrOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange BitwiseOrOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitwiseOrOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitwiseOrOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitwiseOrOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseOrOp::result() {
  return *getODSResults(0).begin();
}

void BitwiseOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void BitwiseOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitwiseOrOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void BitwiseOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void BitwiseOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult BitwiseOrOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void BitwiseOrOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult BitwiseOrOp::verify() {
  if (failed(BitwiseOrOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void BitwiseOrOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BitwiseXorOp definitions
//===----------------------------------------------------------------------===//

BitwiseXorOpAdaptor::BitwiseXorOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BitwiseXorOpAdaptor::BitwiseXorOpAdaptor(BitwiseXorOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BitwiseXorOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange BitwiseXorOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseXorOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitwiseXorOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult BitwiseXorOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BitwiseXorOp::getOperationName() {
  return "spv.BitwiseXor";
}

std::pair<unsigned, unsigned> BitwiseXorOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range BitwiseXorOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseXorOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value BitwiseXorOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange BitwiseXorOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange BitwiseXorOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BitwiseXorOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BitwiseXorOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BitwiseXorOp::result() {
  return *getODSResults(0).begin();
}

void BitwiseXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void BitwiseXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BitwiseXorOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void BitwiseXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void BitwiseXorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult BitwiseXorOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void BitwiseXorOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult BitwiseXorOp::verify() {
  if (failed(BitwiseXorOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void BitwiseXorOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BranchConditionalOp definitions
//===----------------------------------------------------------------------===//

BranchConditionalOpAdaptor::BranchConditionalOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs)  : odsOperands(values), odsAttrs(attrs) {

}

BranchConditionalOpAdaptor::BranchConditionalOpAdaptor(BranchConditionalOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BranchConditionalOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  assert(odsAttrs && "missing segment size attribute for op");
  auto sizeAttr = odsAttrs.get("operand_segment_sizes").cast<::mlir::DenseIntElementsAttr>();

  unsigned start = 0;
  for (unsigned i = 0; i < index; ++i)
    start += (*(sizeAttr.begin() + i)).getZExtValue();
  unsigned size = (*(sizeAttr.begin() + index)).getZExtValue();
  return {start, size};
}

::mlir::ValueRange BranchConditionalOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BranchConditionalOpAdaptor::condition() {
  return *getODSOperands(0).begin();
}

::mlir::ValueRange BranchConditionalOpAdaptor::trueTargetOperands() {
  return getODSOperands(1);
}

::mlir::ValueRange BranchConditionalOpAdaptor::falseTargetOperands() {
  return getODSOperands(2);
}

::mlir::ArrayAttr BranchConditionalOpAdaptor::branch_weights() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::ArrayAttr attr = odsAttrs.get("branch_weights").dyn_cast_or_null<::mlir::ArrayAttr>();
  return attr;
}

::mlir::LogicalResult BranchConditionalOpAdaptor::verify(::mlir::Location loc) {
  {
    auto sizeAttr = odsAttrs.get("operand_segment_sizes").cast<::mlir::DenseIntElementsAttr>();
    auto numElements = sizeAttr.getType().cast<::mlir::ShapedType>().getNumElements();
    if (numElements != 3)
      return emitError(loc, "'operand_segment_sizes' attribute for specifying operand segments "
                       "must have 3 elements");
  }
    {
  auto tblgen_branch_weights = odsAttrs.get("branch_weights");
  if (tblgen_branch_weights) {
    if (!(((tblgen_branch_weights.isa<::mlir::ArrayAttr>())) && (::llvm::all_of(tblgen_branch_weights.cast<::mlir::ArrayAttr>(), [](::mlir::Attribute attr) { return ((attr.isa<::mlir::IntegerAttr>())) && ((attr.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))); })))) return emitError(loc, "'spv.BranchConditional' op ""attribute 'branch_weights' failed to satisfy constraint: 32-bit integer array attribute");
  }
  }
  return success();
}

::llvm::StringRef BranchConditionalOp::getOperationName() {
  return "spv.BranchConditional";
}

std::pair<unsigned, unsigned> BranchConditionalOp::getODSOperandIndexAndLength(unsigned index) {
  auto sizeAttr = getAttrOfType<::mlir::DenseIntElementsAttr>("operand_segment_sizes");

  unsigned start = 0;
  for (unsigned i = 0; i < index; ++i)
    start += (*(sizeAttr.begin() + i)).getZExtValue();
  unsigned size = (*(sizeAttr.begin() + index)).getZExtValue();
  return {start, size};
}

::mlir::Operation::operand_range BranchConditionalOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value BranchConditionalOp::condition() {
  return *getODSOperands(0).begin();
}

::mlir::Operation::operand_range BranchConditionalOp::trueTargetOperands() {
  return getODSOperands(1);
}

::mlir::Operation::operand_range BranchConditionalOp::falseTargetOperands() {
  return getODSOperands(2);
}

::mlir::MutableOperandRange BranchConditionalOp::conditionMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second, ::mlir::MutableOperandRange::OperandSegment(0u, *getOperation()->getMutableAttrDict().getNamed("operand_segment_sizes")));
}

::mlir::MutableOperandRange BranchConditionalOp::trueTargetOperandsMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second, ::mlir::MutableOperandRange::OperandSegment(1u, *getOperation()->getMutableAttrDict().getNamed("operand_segment_sizes")));
}

::mlir::MutableOperandRange BranchConditionalOp::falseTargetOperandsMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second, ::mlir::MutableOperandRange::OperandSegment(2u, *getOperation()->getMutableAttrDict().getNamed("operand_segment_sizes")));
}

std::pair<unsigned, unsigned> BranchConditionalOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BranchConditionalOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Block *BranchConditionalOp::trueTarget() {
  return this->getOperation()->getSuccessor(0);
}

::mlir::Block *BranchConditionalOp::falseTarget() {
  return this->getOperation()->getSuccessor(1);
}

::mlir::ArrayAttr BranchConditionalOp::branch_weightsAttr() {
  return this->getAttr("branch_weights").dyn_cast_or_null<::mlir::ArrayAttr>();
}

::llvm::Optional< ::mlir::ArrayAttr > BranchConditionalOp::branch_weights() {
  auto attr = branch_weightsAttr();
  return attr ? ::llvm::Optional< ::mlir::ArrayAttr >(attr) : (::llvm::None);
}

void BranchConditionalOp::branch_weightsAttr(::mlir::ArrayAttr attr) {
  this->getOperation()->setAttr("branch_weights", attr);
}

void BranchConditionalOp::build(OpBuilder &builder, OperationState &state, Value condition, Block *trueBlock, ValueRange trueArguments, Block *falseBlock, ValueRange falseArguments, Optional<std::pair<uint32_t, uint32_t>> weights ) {
        ArrayAttr weightsAttr;
        if (weights) {
          weightsAttr =
              builder.getI32ArrayAttr({static_cast<int32_t>(weights->first),
                                       static_cast<int32_t>(weights->second)});
        }
        build(builder, state, condition, trueArguments, falseArguments,
              weightsAttr, trueBlock, falseBlock);
      
}

void BranchConditionalOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value condition, ::mlir::ValueRange trueTargetOperands, ::mlir::ValueRange falseTargetOperands, /*optional*/::mlir::ArrayAttr branch_weights, ::mlir::Block *trueTarget, ::mlir::Block *falseTarget) {
  odsState.addOperands(condition);
  odsState.addOperands(trueTargetOperands);
  odsState.addOperands(falseTargetOperands);
  odsState.addAttribute("operand_segment_sizes", odsBuilder.getI32VectorAttr({1, static_cast<int32_t>(trueTargetOperands.size()), static_cast<int32_t>(falseTargetOperands.size())}));
  if (branch_weights) {
  odsState.addAttribute("branch_weights", branch_weights);
  }
  odsState.addSuccessors(trueTarget);
  odsState.addSuccessors(falseTarget);
}

void BranchConditionalOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value condition, ::mlir::ValueRange trueTargetOperands, ::mlir::ValueRange falseTargetOperands, /*optional*/::mlir::ArrayAttr branch_weights, ::mlir::Block *trueTarget, ::mlir::Block *falseTarget) {
  odsState.addOperands(condition);
  odsState.addOperands(trueTargetOperands);
  odsState.addOperands(falseTargetOperands);
  odsState.addAttribute("operand_segment_sizes", odsBuilder.getI32VectorAttr({1, static_cast<int32_t>(trueTargetOperands.size()), static_cast<int32_t>(falseTargetOperands.size())}));
  if (branch_weights) {
  odsState.addAttribute("branch_weights", branch_weights);
  }
  odsState.addSuccessors(trueTarget);
  odsState.addSuccessors(falseTarget);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void BranchConditionalOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult BranchConditionalOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseBranchConditionalOp(parser, result);
}

void BranchConditionalOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult BranchConditionalOp::verify() {
  if (failed(BranchConditionalOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isSignlessInteger(1)))) {
        return emitOpError("operand #") << index << " must be bool, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
{
    unsigned index = 0; (void)index;
  }
  return ::verify(*this);
}











void BranchConditionalOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::BranchOp definitions
//===----------------------------------------------------------------------===//

BranchOpAdaptor::BranchOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

BranchOpAdaptor::BranchOpAdaptor(BranchOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> BranchOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange BranchOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::ValueRange BranchOpAdaptor::targetOperands() {
  return getODSOperands(0);
}

::mlir::LogicalResult BranchOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef BranchOp::getOperationName() {
  return "spv.Branch";
}

std::pair<unsigned, unsigned> BranchOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range BranchOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Operation::operand_range BranchOp::targetOperands() {
  return getODSOperands(0);
}

::mlir::MutableOperandRange BranchOp::targetOperandsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> BranchOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range BranchOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Block *BranchOp::target() {
  return this->getOperation()->getSuccessor(0);
}

void BranchOp::build(OpBuilder &, OperationState &state, Block *successor, ValueRange arguments ) {
        state.addSuccessors(successor);
        state.addOperands(arguments);
      
}

::mlir::LogicalResult BranchOp::verify() {
  if (failed(BranchOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
{
    unsigned index = 0; (void)index;
  }
  return success();
}











::mlir::ParseResult BranchOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> targetOperandsOperands;
  ::llvm::SMLoc targetOperandsOperandsLoc = parser.getCurrentLocation();
  (void)targetOperandsOperandsLoc;
  ::mlir::SmallVector<::mlir::Type, 1> targetOperandsTypes;

  ::mlir::Block *targetSuccessor = nullptr;
  if (parser.parseSuccessor(targetSuccessor))
    return failure();
  if (succeeded(parser.parseOptionalLParen())) {

  if (parser.parseOperandList(targetOperandsOperands))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseTypeList(targetOperandsTypes))
    return failure();
  if (parser.parseRParen())
    return failure();
  }
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.resolveOperands(targetOperandsOperands, targetOperandsTypes, targetOperandsOperandsLoc, result.operands))
    return failure();
  result.addSuccessors(targetSuccessor);
  return success();
}

void BranchOp::print(OpAsmPrinter &p) {
  p << "spv.Branch";
  p << " ";
  p << target();
  if (!targetOperands().empty()) {
  p << "(";
  p << targetOperands();
  p << " " << ":";
  p << " ";
  p << targetOperands().getTypes();
  p << ")";
  }
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
}

void BranchOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::CompositeConstructOp definitions
//===----------------------------------------------------------------------===//

CompositeConstructOpAdaptor::CompositeConstructOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CompositeConstructOpAdaptor::CompositeConstructOpAdaptor(CompositeConstructOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CompositeConstructOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange CompositeConstructOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::ValueRange CompositeConstructOpAdaptor::constituents() {
  return getODSOperands(0);
}

::mlir::LogicalResult CompositeConstructOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef CompositeConstructOp::getOperationName() {
  return "spv.CompositeConstruct";
}

std::pair<unsigned, unsigned> CompositeConstructOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range CompositeConstructOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Operation::operand_range CompositeConstructOp::constituents() {
  return getODSOperands(0);
}

::mlir::MutableOperandRange CompositeConstructOp::constituentsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> CompositeConstructOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CompositeConstructOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CompositeConstructOp::result() {
  return *getODSResults(0).begin();
}

void CompositeConstructOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::ValueRange constituents) {
  odsState.addOperands(constituents);
  odsState.addTypes(result);
}

void CompositeConstructOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult CompositeConstructOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseCompositeConstructOp(parser, result);
}

void CompositeConstructOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult CompositeConstructOp::verify() {
  if (failed(CompositeConstructOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}









void CompositeConstructOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::CompositeExtractOp definitions
//===----------------------------------------------------------------------===//

CompositeExtractOpAdaptor::CompositeExtractOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CompositeExtractOpAdaptor::CompositeExtractOpAdaptor(CompositeExtractOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CompositeExtractOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange CompositeExtractOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CompositeExtractOpAdaptor::composite() {
  return *getODSOperands(0).begin();
}

::mlir::ArrayAttr CompositeExtractOpAdaptor::indices() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::ArrayAttr attr = odsAttrs.get("indices").cast<::mlir::ArrayAttr>();
  return attr;
}

::mlir::LogicalResult CompositeExtractOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_indices = odsAttrs.get("indices");
  if (!tblgen_indices) return emitError(loc, "'spv.CompositeExtract' op ""requires attribute 'indices'");
    if (!(((tblgen_indices.isa<::mlir::ArrayAttr>())) && (::llvm::all_of(tblgen_indices.cast<::mlir::ArrayAttr>(), [](::mlir::Attribute attr) { return ((attr.isa<::mlir::IntegerAttr>())) && ((attr.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))); })))) return emitError(loc, "'spv.CompositeExtract' op ""attribute 'indices' failed to satisfy constraint: 32-bit integer array attribute");
  }
  return success();
}

::llvm::StringRef CompositeExtractOp::getOperationName() {
  return "spv.CompositeExtract";
}

std::pair<unsigned, unsigned> CompositeExtractOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range CompositeExtractOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CompositeExtractOp::composite() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange CompositeExtractOp::compositeMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> CompositeExtractOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CompositeExtractOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CompositeExtractOp::component() {
  return *getODSResults(0).begin();
}

::mlir::ArrayAttr CompositeExtractOp::indicesAttr() {
  return this->getAttr("indices").cast<::mlir::ArrayAttr>();
}

::mlir::ArrayAttr CompositeExtractOp::indices() {
  auto attr = indicesAttr();
  return attr;
}

void CompositeExtractOp::indicesAttr(::mlir::ArrayAttr attr) {
  this->getOperation()->setAttr("indices", attr);
}



void CompositeExtractOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type component, ::mlir::Value composite, ::mlir::ArrayAttr indices) {
  odsState.addOperands(composite);
  odsState.addAttribute("indices", indices);
  odsState.addTypes(component);
}

void CompositeExtractOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value composite, ::mlir::ArrayAttr indices) {
  odsState.addOperands(composite);
  odsState.addAttribute("indices", indices);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void CompositeExtractOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult CompositeExtractOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseCompositeExtractOp(parser, result);
}

void CompositeExtractOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult CompositeExtractOp::verify() {
  if (failed(CompositeExtractOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}











void CompositeExtractOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::CompositeInsertOp definitions
//===----------------------------------------------------------------------===//

CompositeInsertOpAdaptor::CompositeInsertOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CompositeInsertOpAdaptor::CompositeInsertOpAdaptor(CompositeInsertOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CompositeInsertOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange CompositeInsertOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CompositeInsertOpAdaptor::object() {
  return *getODSOperands(0).begin();
}

::mlir::Value CompositeInsertOpAdaptor::composite() {
  return *getODSOperands(1).begin();
}

::mlir::ArrayAttr CompositeInsertOpAdaptor::indices() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::ArrayAttr attr = odsAttrs.get("indices").cast<::mlir::ArrayAttr>();
  return attr;
}

::mlir::LogicalResult CompositeInsertOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_indices = odsAttrs.get("indices");
  if (!tblgen_indices) return emitError(loc, "'spv.CompositeInsert' op ""requires attribute 'indices'");
    if (!(((tblgen_indices.isa<::mlir::ArrayAttr>())) && (::llvm::all_of(tblgen_indices.cast<::mlir::ArrayAttr>(), [](::mlir::Attribute attr) { return ((attr.isa<::mlir::IntegerAttr>())) && ((attr.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))); })))) return emitError(loc, "'spv.CompositeInsert' op ""attribute 'indices' failed to satisfy constraint: 32-bit integer array attribute");
  }
  return success();
}

::llvm::StringRef CompositeInsertOp::getOperationName() {
  return "spv.CompositeInsert";
}

std::pair<unsigned, unsigned> CompositeInsertOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range CompositeInsertOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CompositeInsertOp::object() {
  return *getODSOperands(0).begin();
}

::mlir::Value CompositeInsertOp::composite() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange CompositeInsertOp::objectMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CompositeInsertOp::compositeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> CompositeInsertOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CompositeInsertOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CompositeInsertOp::result() {
  return *getODSResults(0).begin();
}

::mlir::ArrayAttr CompositeInsertOp::indicesAttr() {
  return this->getAttr("indices").cast<::mlir::ArrayAttr>();
}

::mlir::ArrayAttr CompositeInsertOp::indices() {
  auto attr = indicesAttr();
  return attr;
}

void CompositeInsertOp::indicesAttr(::mlir::ArrayAttr attr) {
  this->getOperation()->setAttr("indices", attr);
}

void CompositeInsertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value object, ::mlir::Value composite, ::mlir::ArrayAttr indices) {
  odsState.addOperands(object);
  odsState.addOperands(composite);
  odsState.addAttribute("indices", indices);
  odsState.addTypes(result);
}

void CompositeInsertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value object, ::mlir::Value composite, ::mlir::ArrayAttr indices) {
  odsState.addOperands(object);
  odsState.addOperands(composite);
  odsState.addAttribute("indices", indices);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void CompositeInsertOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult CompositeInsertOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseCompositeInsertOp(parser, result);
}

void CompositeInsertOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult CompositeInsertOp::verify() {
  if (failed(CompositeInsertOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}









void CompositeInsertOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ConstantOp definitions
//===----------------------------------------------------------------------===//

ConstantOpAdaptor::ConstantOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ConstantOpAdaptor::ConstantOpAdaptor(ConstantOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ConstantOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ConstantOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Attribute ConstantOpAdaptor::value() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::Attribute attr = odsAttrs.get("value").cast<::mlir::Attribute>();
  return attr;
}

::mlir::LogicalResult ConstantOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_value = odsAttrs.get("value");
  if (!tblgen_value) return emitError(loc, "'spv.constant' op ""requires attribute 'value'");
    if (!((true))) return emitError(loc, "'spv.constant' op ""attribute 'value' failed to satisfy constraint: any attribute");
  }
  return success();
}

::llvm::StringRef ConstantOp::getOperationName() {
  return "spv.constant";
}

std::pair<unsigned, unsigned> ConstantOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ConstantOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> ConstantOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ConstantOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConstantOp::constant() {
  return *getODSResults(0).begin();
}

::mlir::Attribute ConstantOp::valueAttr() {
  return this->getAttr("value").cast<::mlir::Attribute>();
}

::mlir::Attribute ConstantOp::value() {
  auto attr = valueAttr();
  return attr;
}

void ConstantOp::valueAttr(::mlir::Attribute attr) {
  this->getOperation()->setAttr("value", attr);
}

void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type constant, ::mlir::Attribute value) {
  odsState.addAttribute("value", value);
  odsState.addTypes(constant);
}

void ConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Attribute value) {
  odsState.addAttribute("value", value);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ConstantOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ConstantOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseConstantOp(parser, result);
}

void ConstantOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult ConstantOp::verify() {
  if (failed(ConstantOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}











void ConstantOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ControlBarrierOp definitions
//===----------------------------------------------------------------------===//

ControlBarrierOpAdaptor::ControlBarrierOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ControlBarrierOpAdaptor::ControlBarrierOpAdaptor(ControlBarrierOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ControlBarrierOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ControlBarrierOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr ControlBarrierOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr ControlBarrierOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr ControlBarrierOpAdaptor::memory_semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult ControlBarrierOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.ControlBarrier' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.ControlBarrier' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.ControlBarrier' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.ControlBarrier' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_memory_semantics = odsAttrs.get("memory_semantics");
  if (!tblgen_memory_semantics) return emitError(loc, "'spv.ControlBarrier' op ""requires attribute 'memory_semantics'");
    if (!((((tblgen_memory_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_memory_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.ControlBarrier' op ""attribute 'memory_semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef ControlBarrierOp::getOperationName() {
  return "spv.ControlBarrier";
}

std::pair<unsigned, unsigned> ControlBarrierOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ControlBarrierOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> ControlBarrierOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ControlBarrierOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr ControlBarrierOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope ControlBarrierOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr ControlBarrierOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope ControlBarrierOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr ControlBarrierOp::memory_semanticsAttr() {
  return this->getAttr("memory_semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics ControlBarrierOp::memory_semantics() {
  auto attr = memory_semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void ControlBarrierOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void ControlBarrierOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void ControlBarrierOp::memory_semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_semantics", attr);
}

void ControlBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr memory_semantics) {
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("memory_semantics", memory_semantics);
}

void ControlBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr memory_semantics) {
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("memory_semantics", memory_semantics);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ControlBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics memory_semantics) {
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("memory_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_semantics)));
}

void ControlBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics memory_semantics) {
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("memory_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_semantics)));
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ControlBarrierOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult ControlBarrierOp::verify() {
  if (failed(ControlBarrierOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  return verifyMemorySemantics(*this);
}









::mlir::ParseResult ControlBarrierOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  {
    ::mlir::StringAttr attrVal;
    ::mlir::NamedAttrList attrStorage;
    auto loc = parser.getCurrentLocation();
    if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                              "execution_scope", attrStorage))
      return failure();

    auto attrOptional = ::mlir::spirv::symbolizeScope(attrVal.getValue());
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "execution_scope attribute specification: " << attrVal;

    result.addAttribute("execution_scope", parser.getBuilder().getI32IntegerAttr(static_cast<int32_t>(attrOptional.getValue())));
  }
  if (parser.parseComma())
    return failure();

  {
    ::mlir::StringAttr attrVal;
    ::mlir::NamedAttrList attrStorage;
    auto loc = parser.getCurrentLocation();
    if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                              "memory_scope", attrStorage))
      return failure();

    auto attrOptional = ::mlir::spirv::symbolizeScope(attrVal.getValue());
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "memory_scope attribute specification: " << attrVal;

    result.addAttribute("memory_scope", parser.getBuilder().getI32IntegerAttr(static_cast<int32_t>(attrOptional.getValue())));
  }
  if (parser.parseComma())
    return failure();

  {
    ::mlir::StringAttr attrVal;
    ::mlir::NamedAttrList attrStorage;
    auto loc = parser.getCurrentLocation();
    if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                              "memory_semantics", attrStorage))
      return failure();

    auto attrOptional = ::mlir::spirv::symbolizeMemorySemantics(attrVal.getValue());
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "memory_semantics attribute specification: " << attrVal;

    result.addAttribute("memory_semantics", parser.getBuilder().getI32IntegerAttr(static_cast<int32_t>(attrOptional.getValue())));
  }
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  return success();
}

void ControlBarrierOp::print(OpAsmPrinter &p) {
  p << "spv.ControlBarrier";
  p << " ";
  p << "\"" << stringifyScope(execution_scope()) << "\"";
  p << ",";
  p << " ";
  p << "\"" << stringifyScope(memory_scope()) << "\"";
  p << ",";
  p << " ";
  p << "\"" << stringifyMemorySemantics(memory_semantics()) << "\"";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"execution_scope", "memory_scope", "memory_semantics"});
}


//===----------------------------------------------------------------------===//
// spirv::ConvertFToSOp definitions
//===----------------------------------------------------------------------===//

ConvertFToSOpAdaptor::ConvertFToSOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ConvertFToSOpAdaptor::ConvertFToSOpAdaptor(ConvertFToSOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ConvertFToSOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ConvertFToSOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertFToSOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult ConvertFToSOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ConvertFToSOp::getOperationName() {
  return "spv.ConvertFToS";
}

std::pair<unsigned, unsigned> ConvertFToSOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ConvertFToSOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertFToSOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange ConvertFToSOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ConvertFToSOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ConvertFToSOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertFToSOp::result() {
  return *getODSResults(0).begin();
}

void ConvertFToSOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void ConvertFToSOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ConvertFToSOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ConvertFToSOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void ConvertFToSOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult ConvertFToSOp::verify() {
  if (failed(ConvertFToSOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyCastOp(this->getOperation());
}









void ConvertFToSOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ConvertFToUOp definitions
//===----------------------------------------------------------------------===//

ConvertFToUOpAdaptor::ConvertFToUOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ConvertFToUOpAdaptor::ConvertFToUOpAdaptor(ConvertFToUOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ConvertFToUOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ConvertFToUOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertFToUOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult ConvertFToUOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ConvertFToUOp::getOperationName() {
  return "spv.ConvertFToU";
}

std::pair<unsigned, unsigned> ConvertFToUOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ConvertFToUOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertFToUOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange ConvertFToUOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ConvertFToUOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ConvertFToUOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertFToUOp::result() {
  return *getODSResults(0).begin();
}

void ConvertFToUOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void ConvertFToUOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ConvertFToUOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ConvertFToUOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void ConvertFToUOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult ConvertFToUOp::verify() {
  if (failed(ConvertFToUOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyCastOp(this->getOperation());
}









void ConvertFToUOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ConvertSToFOp definitions
//===----------------------------------------------------------------------===//

ConvertSToFOpAdaptor::ConvertSToFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ConvertSToFOpAdaptor::ConvertSToFOpAdaptor(ConvertSToFOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ConvertSToFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ConvertSToFOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertSToFOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult ConvertSToFOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ConvertSToFOp::getOperationName() {
  return "spv.ConvertSToF";
}

std::pair<unsigned, unsigned> ConvertSToFOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ConvertSToFOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertSToFOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange ConvertSToFOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ConvertSToFOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ConvertSToFOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertSToFOp::result() {
  return *getODSResults(0).begin();
}

void ConvertSToFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void ConvertSToFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ConvertSToFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ConvertSToFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void ConvertSToFOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult ConvertSToFOp::verify() {
  if (failed(ConvertSToFOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyCastOp(this->getOperation());
}









void ConvertSToFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ConvertUToFOp definitions
//===----------------------------------------------------------------------===//

ConvertUToFOpAdaptor::ConvertUToFOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ConvertUToFOpAdaptor::ConvertUToFOpAdaptor(ConvertUToFOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ConvertUToFOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ConvertUToFOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertUToFOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult ConvertUToFOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ConvertUToFOp::getOperationName() {
  return "spv.ConvertUToF";
}

std::pair<unsigned, unsigned> ConvertUToFOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ConvertUToFOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertUToFOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange ConvertUToFOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ConvertUToFOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ConvertUToFOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ConvertUToFOp::result() {
  return *getODSResults(0).begin();
}

void ConvertUToFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void ConvertUToFOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ConvertUToFOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ConvertUToFOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void ConvertUToFOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult ConvertUToFOp::verify() {
  if (failed(ConvertUToFOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyCastOp(this->getOperation());
}









void ConvertUToFOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::CooperativeMatrixLengthNVOp definitions
//===----------------------------------------------------------------------===//

CooperativeMatrixLengthNVOpAdaptor::CooperativeMatrixLengthNVOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CooperativeMatrixLengthNVOpAdaptor::CooperativeMatrixLengthNVOpAdaptor(CooperativeMatrixLengthNVOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CooperativeMatrixLengthNVOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange CooperativeMatrixLengthNVOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::TypeAttr CooperativeMatrixLengthNVOpAdaptor::type() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::TypeAttr attr = odsAttrs.get("type").cast<::mlir::TypeAttr>();
  return attr;
}

::mlir::LogicalResult CooperativeMatrixLengthNVOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_type = odsAttrs.get("type");
  if (!tblgen_type) return emitError(loc, "'spv.CooperativeMatrixLengthNV' op ""requires attribute 'type'");
    if (!(((tblgen_type.isa<::mlir::TypeAttr>())) && ((tblgen_type.cast<::mlir::TypeAttr>().getValue().isa<::mlir::Type>())))) return emitError(loc, "'spv.CooperativeMatrixLengthNV' op ""attribute 'type' failed to satisfy constraint: any type attribute");
  }
  return success();
}

::llvm::StringRef CooperativeMatrixLengthNVOp::getOperationName() {
  return "spv.CooperativeMatrixLengthNV";
}

std::pair<unsigned, unsigned> CooperativeMatrixLengthNVOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range CooperativeMatrixLengthNVOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> CooperativeMatrixLengthNVOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CooperativeMatrixLengthNVOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixLengthNVOp::result() {
  return *getODSResults(0).begin();
}

::mlir::TypeAttr CooperativeMatrixLengthNVOp::typeAttr() {
  return this->getAttr("type").cast<::mlir::TypeAttr>();
}

::mlir::Type CooperativeMatrixLengthNVOp::type() {
  auto attr = typeAttr();
  return attr.getValue().cast<::mlir::Type>();
}

void CooperativeMatrixLengthNVOp::typeAttr(::mlir::TypeAttr attr) {
  this->getOperation()->setAttr("type", attr);
}

void CooperativeMatrixLengthNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::TypeAttr type) {
  odsState.addAttribute("type", type);
  odsState.addTypes(result);
}

void CooperativeMatrixLengthNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::TypeAttr type) {
  odsState.addAttribute("type", type);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void CooperativeMatrixLengthNVOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult CooperativeMatrixLengthNVOp::verify() {
  if (failed(CooperativeMatrixLengthNVOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isSignlessInteger(32)))) {
        return emitOpError("result #") << index << " must be Int32, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









::mlir::ParseResult CooperativeMatrixLengthNVOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  ::mlir::TypeAttr typeAttr;
  if (parser.parseAttribute(typeAttr, parser.getBuilder().getType<::mlir::NoneType>(), "type", result.attributes))
    return failure();
  ::mlir::Type odsBuildableType0 = parser.getBuilder().getIntegerType(32);
  result.addTypes(odsBuildableType0);
  return success();
}

void CooperativeMatrixLengthNVOp::print(OpAsmPrinter &p) {
  p << "spv.CooperativeMatrixLengthNV";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"type"});
  p << " " << ":";
  p << " ";
  p.printAttributeWithoutType(typeAttr());
}

void CooperativeMatrixLengthNVOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::CooperativeMatrixLoadNVOp definitions
//===----------------------------------------------------------------------===//

CooperativeMatrixLoadNVOpAdaptor::CooperativeMatrixLoadNVOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CooperativeMatrixLoadNVOpAdaptor::CooperativeMatrixLoadNVOpAdaptor(CooperativeMatrixLoadNVOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CooperativeMatrixLoadNVOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange CooperativeMatrixLoadNVOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixLoadNVOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value CooperativeMatrixLoadNVOpAdaptor::stride() {
  return *getODSOperands(1).begin();
}

::mlir::Value CooperativeMatrixLoadNVOpAdaptor::columnmajor() {
  return *getODSOperands(2).begin();
}

::mlir::IntegerAttr CooperativeMatrixLoadNVOpAdaptor::memory_access() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult CooperativeMatrixLoadNVOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_access = odsAttrs.get("memory_access");
  if (tblgen_memory_access) {
    if (!((((tblgen_memory_access.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_access.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemoryAccess(tblgen_memory_access.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.CooperativeMatrixLoadNV' op ""attribute 'memory_access' failed to satisfy constraint: valid SPIR-V MemoryAccess");
  }
  }
  return success();
}

::llvm::StringRef CooperativeMatrixLoadNVOp::getOperationName() {
  return "spv.CooperativeMatrixLoadNV";
}

std::pair<unsigned, unsigned> CooperativeMatrixLoadNVOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range CooperativeMatrixLoadNVOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixLoadNVOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value CooperativeMatrixLoadNVOp::stride() {
  return *getODSOperands(1).begin();
}

::mlir::Value CooperativeMatrixLoadNVOp::columnmajor() {
  return *getODSOperands(2).begin();
}

::mlir::MutableOperandRange CooperativeMatrixLoadNVOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CooperativeMatrixLoadNVOp::strideMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CooperativeMatrixLoadNVOp::columnmajorMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> CooperativeMatrixLoadNVOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CooperativeMatrixLoadNVOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixLoadNVOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr CooperativeMatrixLoadNVOp::memory_accessAttr() {
  return this->getAttr("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional<::mlir::spirv::MemoryAccess> CooperativeMatrixLoadNVOp::memory_access() {
  auto attr = memory_accessAttr();
  return attr ? ::llvm::Optional<::mlir::spirv::MemoryAccess>(static_cast<::mlir::spirv::MemoryAccess>(attr.getInt())) : (::llvm::None);
}

void CooperativeMatrixLoadNVOp::memory_accessAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_access", attr);
}

void CooperativeMatrixLoadNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value pointer, ::mlir::Value stride, ::mlir::Value columnmajor, /*optional*/::mlir::IntegerAttr memory_access) {
  odsState.addOperands(pointer);
  odsState.addOperands(stride);
  odsState.addOperands(columnmajor);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  odsState.addTypes(result);
}

void CooperativeMatrixLoadNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::Value stride, ::mlir::Value columnmajor, /*optional*/::mlir::IntegerAttr memory_access) {
  odsState.addOperands(pointer);
  odsState.addOperands(stride);
  odsState.addOperands(columnmajor);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void CooperativeMatrixLoadNVOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 3u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult CooperativeMatrixLoadNVOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseCooperativeMatrixLoadNVOp(parser, result);
}

void CooperativeMatrixLoadNVOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult CooperativeMatrixLoadNVOp::verify() {
  if (failed(CooperativeMatrixLoadNVOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!((v.getType().isSignlessInteger(1)))) {
        return emitOpError("operand #") << index << " must be bool, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V cooperative matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                          result().getType());
}










//===----------------------------------------------------------------------===//
// spirv::CooperativeMatrixMulAddNVOp definitions
//===----------------------------------------------------------------------===//

CooperativeMatrixMulAddNVOpAdaptor::CooperativeMatrixMulAddNVOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CooperativeMatrixMulAddNVOpAdaptor::CooperativeMatrixMulAddNVOpAdaptor(CooperativeMatrixMulAddNVOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CooperativeMatrixMulAddNVOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange CooperativeMatrixMulAddNVOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixMulAddNVOpAdaptor::a() {
  return *getODSOperands(0).begin();
}

::mlir::Value CooperativeMatrixMulAddNVOpAdaptor::b() {
  return *getODSOperands(1).begin();
}

::mlir::Value CooperativeMatrixMulAddNVOpAdaptor::c() {
  return *getODSOperands(2).begin();
}

::mlir::LogicalResult CooperativeMatrixMulAddNVOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef CooperativeMatrixMulAddNVOp::getOperationName() {
  return "spv.CooperativeMatrixMulAddNV";
}

std::pair<unsigned, unsigned> CooperativeMatrixMulAddNVOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range CooperativeMatrixMulAddNVOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixMulAddNVOp::a() {
  return *getODSOperands(0).begin();
}

::mlir::Value CooperativeMatrixMulAddNVOp::b() {
  return *getODSOperands(1).begin();
}

::mlir::Value CooperativeMatrixMulAddNVOp::c() {
  return *getODSOperands(2).begin();
}

::mlir::MutableOperandRange CooperativeMatrixMulAddNVOp::aMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CooperativeMatrixMulAddNVOp::bMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CooperativeMatrixMulAddNVOp::cMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> CooperativeMatrixMulAddNVOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CooperativeMatrixMulAddNVOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixMulAddNVOp::result() {
  return *getODSResults(0).begin();
}

void CooperativeMatrixMulAddNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value a, ::mlir::Value b, ::mlir::Value c) {
  odsState.addOperands(a);
  odsState.addOperands(b);
  odsState.addOperands(c);
  odsState.addTypes(result);
}

void CooperativeMatrixMulAddNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value a, ::mlir::Value b, ::mlir::Value c) {
  odsState.addOperands(a);
  odsState.addOperands(b);
  odsState.addOperands(c);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void CooperativeMatrixMulAddNVOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 3u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult CooperativeMatrixMulAddNVOp::verify() {
  if (failed(CooperativeMatrixMulAddNVOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V cooperative matrix type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V cooperative matrix type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V cooperative matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V cooperative matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  if (!((::llvm::is_splat(::llvm::makeArrayRef({(*this->getODSOperands(2).begin()).getType(), (*this->getODSResults(0).begin()).getType()})))))
    return emitOpError("failed to verify that all of {c, result} have same type");
  return verifyCoopMatrixMulAdd(*this);
}









::mlir::ParseResult CooperativeMatrixMulAddNVOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type aRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> aTypes(aRawTypes);
  ::mlir::Type bRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> bTypes(bRawTypes);
  ::mlir::Type cRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> cTypes(cRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(aRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(bRawTypes[0]))
    return failure();
  if (parser.parseArrow())
    return failure();

  if (parser.parseType(cRawTypes[0]))
    return failure();
  result.addTypes(cTypes);
  if (parser.resolveOperands(allOperands, ::llvm::concat<const Type>(::llvm::ArrayRef<::mlir::Type>(aTypes), ::llvm::ArrayRef<::mlir::Type>(bTypes), ::llvm::ArrayRef<::mlir::Type>(cTypes)), allOperandLoc, result.operands))
    return failure();
  return success();
}

void CooperativeMatrixMulAddNVOp::print(OpAsmPrinter &p) {
  p << "spv.CooperativeMatrixMulAddNV";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(a().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(b().getType());
  p << " " << "->";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(c().getType());
}

void CooperativeMatrixMulAddNVOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::CooperativeMatrixStoreNVOp definitions
//===----------------------------------------------------------------------===//

CooperativeMatrixStoreNVOpAdaptor::CooperativeMatrixStoreNVOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CooperativeMatrixStoreNVOpAdaptor::CooperativeMatrixStoreNVOpAdaptor(CooperativeMatrixStoreNVOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CooperativeMatrixStoreNVOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange CooperativeMatrixStoreNVOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixStoreNVOpAdaptor::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value CooperativeMatrixStoreNVOpAdaptor::object() {
  return *getODSOperands(1).begin();
}

::mlir::Value CooperativeMatrixStoreNVOpAdaptor::stride() {
  return *getODSOperands(2).begin();
}

::mlir::Value CooperativeMatrixStoreNVOpAdaptor::columnmajor() {
  return *getODSOperands(3).begin();
}

::mlir::IntegerAttr CooperativeMatrixStoreNVOpAdaptor::memory_access() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult CooperativeMatrixStoreNVOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_access = odsAttrs.get("memory_access");
  if (tblgen_memory_access) {
    if (!((((tblgen_memory_access.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_access.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemoryAccess(tblgen_memory_access.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.CooperativeMatrixStoreNV' op ""attribute 'memory_access' failed to satisfy constraint: valid SPIR-V MemoryAccess");
  }
  }
  return success();
}

::llvm::StringRef CooperativeMatrixStoreNVOp::getOperationName() {
  return "spv.CooperativeMatrixStoreNV";
}

std::pair<unsigned, unsigned> CooperativeMatrixStoreNVOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range CooperativeMatrixStoreNVOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CooperativeMatrixStoreNVOp::pointer() {
  return *getODSOperands(0).begin();
}

::mlir::Value CooperativeMatrixStoreNVOp::object() {
  return *getODSOperands(1).begin();
}

::mlir::Value CooperativeMatrixStoreNVOp::stride() {
  return *getODSOperands(2).begin();
}

::mlir::Value CooperativeMatrixStoreNVOp::columnmajor() {
  return *getODSOperands(3).begin();
}

::mlir::MutableOperandRange CooperativeMatrixStoreNVOp::pointerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CooperativeMatrixStoreNVOp::objectMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CooperativeMatrixStoreNVOp::strideMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CooperativeMatrixStoreNVOp::columnmajorMutable() {
  auto range = getODSOperandIndexAndLength(3);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> CooperativeMatrixStoreNVOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CooperativeMatrixStoreNVOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr CooperativeMatrixStoreNVOp::memory_accessAttr() {
  return this->getAttr("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional<::mlir::spirv::MemoryAccess> CooperativeMatrixStoreNVOp::memory_access() {
  auto attr = memory_accessAttr();
  return attr ? ::llvm::Optional<::mlir::spirv::MemoryAccess>(static_cast<::mlir::spirv::MemoryAccess>(attr.getInt())) : (::llvm::None);
}

void CooperativeMatrixStoreNVOp::memory_accessAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_access", attr);
}

void CooperativeMatrixStoreNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value pointer, ::mlir::Value object, ::mlir::Value stride, ::mlir::Value columnmajor, /*optional*/::mlir::IntegerAttr memory_access) {
  odsState.addOperands(pointer);
  odsState.addOperands(object);
  odsState.addOperands(stride);
  odsState.addOperands(columnmajor);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
}

void CooperativeMatrixStoreNVOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value pointer, ::mlir::Value object, ::mlir::Value stride, ::mlir::Value columnmajor, /*optional*/::mlir::IntegerAttr memory_access) {
  odsState.addOperands(pointer);
  odsState.addOperands(object);
  odsState.addOperands(stride);
  odsState.addOperands(columnmajor);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void CooperativeMatrixStoreNVOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 4u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult CooperativeMatrixStoreNVOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseCooperativeMatrixStoreNVOp(parser, result);
}

void CooperativeMatrixStoreNVOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult CooperativeMatrixStoreNVOp::verify() {
  if (failed(CooperativeMatrixStoreNVOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V cooperative matrix type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup3 = getODSOperands(3);
    for (::mlir::Value v : valueGroup3) {
      (void)v;
      if (!((v.getType().isSignlessInteger(1)))) {
        return emitOpError("operand #") << index << " must be bool, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
  }
  return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                          object().getType());
}










//===----------------------------------------------------------------------===//
// spirv::CopyMemoryOp definitions
//===----------------------------------------------------------------------===//

CopyMemoryOpAdaptor::CopyMemoryOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

CopyMemoryOpAdaptor::CopyMemoryOpAdaptor(CopyMemoryOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> CopyMemoryOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange CopyMemoryOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CopyMemoryOpAdaptor::target() {
  return *getODSOperands(0).begin();
}

::mlir::Value CopyMemoryOpAdaptor::source() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr CopyMemoryOpAdaptor::memory_access() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr CopyMemoryOpAdaptor::alignment() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr CopyMemoryOpAdaptor::source_memory_access() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("source_memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr CopyMemoryOpAdaptor::source_alignment() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("source_alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult CopyMemoryOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_access = odsAttrs.get("memory_access");
  if (tblgen_memory_access) {
    if (!((((tblgen_memory_access.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_access.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemoryAccess(tblgen_memory_access.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.CopyMemory' op ""attribute 'memory_access' failed to satisfy constraint: valid SPIR-V MemoryAccess");
  }
  }
  {
  auto tblgen_alignment = odsAttrs.get("alignment");
  if (tblgen_alignment) {
    if (!(((tblgen_alignment.isa<::mlir::IntegerAttr>())) && ((tblgen_alignment.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))))) return emitError(loc, "'spv.CopyMemory' op ""attribute 'alignment' failed to satisfy constraint: 32-bit signless integer attribute");
  }
  }
  {
  auto tblgen_source_memory_access = odsAttrs.get("source_memory_access");
  if (tblgen_source_memory_access) {
    if (!((((tblgen_source_memory_access.isa<::mlir::IntegerAttr>())) && ((tblgen_source_memory_access.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemoryAccess(tblgen_source_memory_access.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.CopyMemory' op ""attribute 'source_memory_access' failed to satisfy constraint: valid SPIR-V MemoryAccess");
  }
  }
  {
  auto tblgen_source_alignment = odsAttrs.get("source_alignment");
  if (tblgen_source_alignment) {
    if (!(((tblgen_source_alignment.isa<::mlir::IntegerAttr>())) && ((tblgen_source_alignment.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))))) return emitError(loc, "'spv.CopyMemory' op ""attribute 'source_alignment' failed to satisfy constraint: 32-bit signless integer attribute");
  }
  }
  return success();
}

::llvm::StringRef CopyMemoryOp::getOperationName() {
  return "spv.CopyMemory";
}

std::pair<unsigned, unsigned> CopyMemoryOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range CopyMemoryOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value CopyMemoryOp::target() {
  return *getODSOperands(0).begin();
}

::mlir::Value CopyMemoryOp::source() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange CopyMemoryOp::targetMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange CopyMemoryOp::sourceMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> CopyMemoryOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range CopyMemoryOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr CopyMemoryOp::memory_accessAttr() {
  return this->getAttr("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional<::mlir::spirv::MemoryAccess> CopyMemoryOp::memory_access() {
  auto attr = memory_accessAttr();
  return attr ? ::llvm::Optional<::mlir::spirv::MemoryAccess>(static_cast<::mlir::spirv::MemoryAccess>(attr.getInt())) : (::llvm::None);
}

::mlir::IntegerAttr CopyMemoryOp::alignmentAttr() {
  return this->getAttr("alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional< ::llvm::APInt > CopyMemoryOp::alignment() {
  auto attr = alignmentAttr();
  return attr ? ::llvm::Optional< ::llvm::APInt >(attr.getValue()) : (::llvm::None);
}

::mlir::IntegerAttr CopyMemoryOp::source_memory_accessAttr() {
  return this->getAttr("source_memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional<::mlir::spirv::MemoryAccess> CopyMemoryOp::source_memory_access() {
  auto attr = source_memory_accessAttr();
  return attr ? ::llvm::Optional<::mlir::spirv::MemoryAccess>(static_cast<::mlir::spirv::MemoryAccess>(attr.getInt())) : (::llvm::None);
}

::mlir::IntegerAttr CopyMemoryOp::source_alignmentAttr() {
  return this->getAttr("source_alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional< ::llvm::APInt > CopyMemoryOp::source_alignment() {
  auto attr = source_alignmentAttr();
  return attr ? ::llvm::Optional< ::llvm::APInt >(attr.getValue()) : (::llvm::None);
}

void CopyMemoryOp::memory_accessAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_access", attr);
}

void CopyMemoryOp::alignmentAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("alignment", attr);
}

void CopyMemoryOp::source_memory_accessAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("source_memory_access", attr);
}

void CopyMemoryOp::source_alignmentAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("source_alignment", attr);
}

void CopyMemoryOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value target, ::mlir::Value source, /*optional*/::mlir::IntegerAttr memory_access, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::IntegerAttr source_memory_access, /*optional*/::mlir::IntegerAttr source_alignment) {
  odsState.addOperands(target);
  odsState.addOperands(source);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  if (alignment) {
  odsState.addAttribute("alignment", alignment);
  }
  if (source_memory_access) {
  odsState.addAttribute("source_memory_access", source_memory_access);
  }
  if (source_alignment) {
  odsState.addAttribute("source_alignment", source_alignment);
  }
}

void CopyMemoryOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value target, ::mlir::Value source, /*optional*/::mlir::IntegerAttr memory_access, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::IntegerAttr source_memory_access, /*optional*/::mlir::IntegerAttr source_alignment) {
  odsState.addOperands(target);
  odsState.addOperands(source);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  if (alignment) {
  odsState.addAttribute("alignment", alignment);
  }
  if (source_memory_access) {
  odsState.addAttribute("source_memory_access", source_memory_access);
  }
  if (source_alignment) {
  odsState.addAttribute("source_alignment", source_alignment);
  }
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void CopyMemoryOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult CopyMemoryOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseCopyMemoryOp(parser, result);
}

void CopyMemoryOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult CopyMemoryOp::verify() {
  if (failed(CopyMemoryOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
  }
  return verifyCopyMemory(*this);
}










//===----------------------------------------------------------------------===//
// spirv::EntryPointOp definitions
//===----------------------------------------------------------------------===//

EntryPointOpAdaptor::EntryPointOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

EntryPointOpAdaptor::EntryPointOpAdaptor(EntryPointOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> EntryPointOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange EntryPointOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr EntryPointOpAdaptor::execution_model() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_model").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::FlatSymbolRefAttr EntryPointOpAdaptor::fn() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::FlatSymbolRefAttr attr = odsAttrs.get("fn").cast<::mlir::FlatSymbolRefAttr>();
  return attr;
}

::mlir::ArrayAttr EntryPointOpAdaptor::interface() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::ArrayAttr attr = odsAttrs.get("interface").cast<::mlir::ArrayAttr>();
  return attr;
}

::mlir::LogicalResult EntryPointOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_model = odsAttrs.get("execution_model");
  if (!tblgen_execution_model) return emitError(loc, "'spv.EntryPoint' op ""requires attribute 'execution_model'");
    if (!((((tblgen_execution_model.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_model.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeExecutionModel(tblgen_execution_model.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.EntryPoint' op ""attribute 'execution_model' failed to satisfy constraint: valid SPIR-V ExecutionModel");
  }
  {
  auto tblgen_fn = odsAttrs.get("fn");
  if (!tblgen_fn) return emitError(loc, "'spv.EntryPoint' op ""requires attribute 'fn'");
    if (!((tblgen_fn.isa<::mlir::FlatSymbolRefAttr>()))) return emitError(loc, "'spv.EntryPoint' op ""attribute 'fn' failed to satisfy constraint: flat symbol reference attribute");
  }
  {
  auto tblgen_interface = odsAttrs.get("interface");
  if (!tblgen_interface) return emitError(loc, "'spv.EntryPoint' op ""requires attribute 'interface'");
    if (!(((tblgen_interface.isa<::mlir::ArrayAttr>())) && (::llvm::all_of(tblgen_interface.cast<::mlir::ArrayAttr>(), [](::mlir::Attribute attr) { return (attr.isa<::mlir::SymbolRefAttr>()); })))) return emitError(loc, "'spv.EntryPoint' op ""attribute 'interface' failed to satisfy constraint: symbol ref array attribute");
  }
  return success();
}

::llvm::StringRef EntryPointOp::getOperationName() {
  return "spv.EntryPoint";
}

std::pair<unsigned, unsigned> EntryPointOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range EntryPointOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> EntryPointOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range EntryPointOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr EntryPointOp::execution_modelAttr() {
  return this->getAttr("execution_model").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::ExecutionModel EntryPointOp::execution_model() {
  auto attr = execution_modelAttr();
  return static_cast<::mlir::spirv::ExecutionModel>(attr.getInt());
}

::mlir::FlatSymbolRefAttr EntryPointOp::fnAttr() {
  return this->getAttr("fn").cast<::mlir::FlatSymbolRefAttr>();
}

::llvm::StringRef EntryPointOp::fn() {
  auto attr = fnAttr();
  return attr.getValue();
}

::mlir::ArrayAttr EntryPointOp::interfaceAttr() {
  return this->getAttr("interface").cast<::mlir::ArrayAttr>();
}

::mlir::ArrayAttr EntryPointOp::interface() {
  auto attr = interfaceAttr();
  return attr;
}

void EntryPointOp::execution_modelAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_model", attr);
}

void EntryPointOp::fnAttr(::mlir::FlatSymbolRefAttr attr) {
  this->getOperation()->setAttr("fn", attr);
}

void EntryPointOp::interfaceAttr(::mlir::ArrayAttr attr) {
  this->getOperation()->setAttr("interface", attr);
}



void EntryPointOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr execution_model, ::mlir::FlatSymbolRefAttr fn, ::mlir::ArrayAttr interface) {
  odsState.addAttribute("execution_model", execution_model);
  odsState.addAttribute("fn", fn);
  odsState.addAttribute("interface", interface);
}

void EntryPointOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_model, ::mlir::FlatSymbolRefAttr fn, ::mlir::ArrayAttr interface) {
  odsState.addAttribute("execution_model", execution_model);
  odsState.addAttribute("fn", fn);
  odsState.addAttribute("interface", interface);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void EntryPointOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::spirv::ExecutionModel execution_model, ::llvm::StringRef fn, ::mlir::ArrayAttr interface) {
  odsState.addAttribute("execution_model", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_model)));
  odsState.addAttribute("fn", odsBuilder.getSymbolRefAttr(fn));
  odsState.addAttribute("interface", interface);
}

void EntryPointOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::ExecutionModel execution_model, ::llvm::StringRef fn, ::mlir::ArrayAttr interface) {
  odsState.addAttribute("execution_model", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_model)));
  odsState.addAttribute("fn", odsBuilder.getSymbolRefAttr(fn));
  odsState.addAttribute("interface", interface);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void EntryPointOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult EntryPointOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseEntryPointOp(parser, result);
}

void EntryPointOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult EntryPointOp::verify() {
  if (failed(EntryPointOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isDirectInModuleLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a module-like op's block");
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::ExecutionModeOp definitions
//===----------------------------------------------------------------------===//

ExecutionModeOpAdaptor::ExecutionModeOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ExecutionModeOpAdaptor::ExecutionModeOpAdaptor(ExecutionModeOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ExecutionModeOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ExecutionModeOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::FlatSymbolRefAttr ExecutionModeOpAdaptor::fn() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::FlatSymbolRefAttr attr = odsAttrs.get("fn").cast<::mlir::FlatSymbolRefAttr>();
  return attr;
}

::mlir::IntegerAttr ExecutionModeOpAdaptor::execution_mode() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_mode").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::ArrayAttr ExecutionModeOpAdaptor::values() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::ArrayAttr attr = odsAttrs.get("values").cast<::mlir::ArrayAttr>();
  return attr;
}

::mlir::LogicalResult ExecutionModeOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_fn = odsAttrs.get("fn");
  if (!tblgen_fn) return emitError(loc, "'spv.ExecutionMode' op ""requires attribute 'fn'");
    if (!((tblgen_fn.isa<::mlir::FlatSymbolRefAttr>()))) return emitError(loc, "'spv.ExecutionMode' op ""attribute 'fn' failed to satisfy constraint: flat symbol reference attribute");
  }
  {
  auto tblgen_execution_mode = odsAttrs.get("execution_mode");
  if (!tblgen_execution_mode) return emitError(loc, "'spv.ExecutionMode' op ""requires attribute 'execution_mode'");
    if (!((((tblgen_execution_mode.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_mode.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeExecutionMode(tblgen_execution_mode.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.ExecutionMode' op ""attribute 'execution_mode' failed to satisfy constraint: valid SPIR-V ExecutionMode");
  }
  {
  auto tblgen_values = odsAttrs.get("values");
  if (!tblgen_values) return emitError(loc, "'spv.ExecutionMode' op ""requires attribute 'values'");
    if (!(((tblgen_values.isa<::mlir::ArrayAttr>())) && (::llvm::all_of(tblgen_values.cast<::mlir::ArrayAttr>(), [](::mlir::Attribute attr) { return ((attr.isa<::mlir::IntegerAttr>())) && ((attr.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))); })))) return emitError(loc, "'spv.ExecutionMode' op ""attribute 'values' failed to satisfy constraint: 32-bit integer array attribute");
  }
  return success();
}

::llvm::StringRef ExecutionModeOp::getOperationName() {
  return "spv.ExecutionMode";
}

std::pair<unsigned, unsigned> ExecutionModeOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ExecutionModeOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> ExecutionModeOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ExecutionModeOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::FlatSymbolRefAttr ExecutionModeOp::fnAttr() {
  return this->getAttr("fn").cast<::mlir::FlatSymbolRefAttr>();
}

::llvm::StringRef ExecutionModeOp::fn() {
  auto attr = fnAttr();
  return attr.getValue();
}

::mlir::IntegerAttr ExecutionModeOp::execution_modeAttr() {
  return this->getAttr("execution_mode").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::ExecutionMode ExecutionModeOp::execution_mode() {
  auto attr = execution_modeAttr();
  return static_cast<::mlir::spirv::ExecutionMode>(attr.getInt());
}

::mlir::ArrayAttr ExecutionModeOp::valuesAttr() {
  return this->getAttr("values").cast<::mlir::ArrayAttr>();
}

::mlir::ArrayAttr ExecutionModeOp::values() {
  auto attr = valuesAttr();
  return attr;
}

void ExecutionModeOp::fnAttr(::mlir::FlatSymbolRefAttr attr) {
  this->getOperation()->setAttr("fn", attr);
}

void ExecutionModeOp::execution_modeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_mode", attr);
}

void ExecutionModeOp::valuesAttr(::mlir::ArrayAttr attr) {
  this->getOperation()->setAttr("values", attr);
}



void ExecutionModeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::FlatSymbolRefAttr fn, ::mlir::IntegerAttr execution_mode, ::mlir::ArrayAttr values) {
  odsState.addAttribute("fn", fn);
  odsState.addAttribute("execution_mode", execution_mode);
  odsState.addAttribute("values", values);
}

void ExecutionModeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::FlatSymbolRefAttr fn, ::mlir::IntegerAttr execution_mode, ::mlir::ArrayAttr values) {
  odsState.addAttribute("fn", fn);
  odsState.addAttribute("execution_mode", execution_mode);
  odsState.addAttribute("values", values);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ExecutionModeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::StringRef fn, ::mlir::spirv::ExecutionMode execution_mode, ::mlir::ArrayAttr values) {
  odsState.addAttribute("fn", odsBuilder.getSymbolRefAttr(fn));
  odsState.addAttribute("execution_mode", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_mode)));
  odsState.addAttribute("values", values);
}

void ExecutionModeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::llvm::StringRef fn, ::mlir::spirv::ExecutionMode execution_mode, ::mlir::ArrayAttr values) {
  odsState.addAttribute("fn", odsBuilder.getSymbolRefAttr(fn));
  odsState.addAttribute("execution_mode", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_mode)));
  odsState.addAttribute("values", values);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ExecutionModeOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ExecutionModeOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseExecutionModeOp(parser, result);
}

void ExecutionModeOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult ExecutionModeOp::verify() {
  if (failed(ExecutionModeOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isDirectInModuleLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a module-like op's block");
  return success();
}










//===----------------------------------------------------------------------===//
// spirv::FAddOp definitions
//===----------------------------------------------------------------------===//

FAddOpAdaptor::FAddOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FAddOpAdaptor::FAddOpAdaptor(FAddOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FAddOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FAddOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FAddOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FAddOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FAddOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FAddOp::getOperationName() {
  return "spv.FAdd";
}

std::pair<unsigned, unsigned> FAddOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FAddOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FAddOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FAddOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FAddOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FAddOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FAddOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FAddOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FAddOp::result() {
  return *getODSResults(0).begin();
}

void FAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FAddOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void FAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void FAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult FAddOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void FAddOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult FAddOp::verify() {
  if (failed(FAddOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FAddOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FConvertOp definitions
//===----------------------------------------------------------------------===//

FConvertOpAdaptor::FConvertOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FConvertOpAdaptor::FConvertOpAdaptor(FConvertOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FConvertOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FConvertOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FConvertOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult FConvertOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FConvertOp::getOperationName() {
  return "spv.FConvert";
}

std::pair<unsigned, unsigned> FConvertOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FConvertOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FConvertOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange FConvertOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FConvertOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FConvertOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FConvertOp::result() {
  return *getODSResults(0).begin();
}

void FConvertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void FConvertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FConvertOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FConvertOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void FConvertOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult FConvertOp::verify() {
  if (failed(FConvertOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyCastOp(this->getOperation(), false);
}









void FConvertOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FDivOp definitions
//===----------------------------------------------------------------------===//

FDivOpAdaptor::FDivOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FDivOpAdaptor::FDivOpAdaptor(FDivOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FDivOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FDivOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FDivOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FDivOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FDivOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FDivOp::getOperationName() {
  return "spv.FDiv";
}

std::pair<unsigned, unsigned> FDivOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FDivOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FDivOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FDivOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FDivOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FDivOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FDivOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FDivOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FDivOp::result() {
  return *getODSResults(0).begin();
}

void FDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FDivOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void FDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void FDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult FDivOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void FDivOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult FDivOp::verify() {
  if (failed(FDivOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FDivOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FModOp definitions
//===----------------------------------------------------------------------===//

FModOpAdaptor::FModOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FModOpAdaptor::FModOpAdaptor(FModOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FModOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FModOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FModOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FModOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FModOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FModOp::getOperationName() {
  return "spv.FMod";
}

std::pair<unsigned, unsigned> FModOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FModOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FModOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FModOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FModOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FModOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FModOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FModOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FModOp::result() {
  return *getODSResults(0).begin();
}

void FModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FModOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void FModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void FModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult FModOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void FModOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult FModOp::verify() {
  if (failed(FModOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FModOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FMulOp definitions
//===----------------------------------------------------------------------===//

FMulOpAdaptor::FMulOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FMulOpAdaptor::FMulOpAdaptor(FMulOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FMulOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FMulOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FMulOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FMulOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FMulOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FMulOp::getOperationName() {
  return "spv.FMul";
}

std::pair<unsigned, unsigned> FMulOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FMulOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FMulOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FMulOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FMulOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FMulOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FMulOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FMulOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FMulOp::result() {
  return *getODSResults(0).begin();
}

void FMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FMulOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void FMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void FMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult FMulOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void FMulOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult FMulOp::verify() {
  if (failed(FMulOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FMulOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FNegateOp definitions
//===----------------------------------------------------------------------===//

FNegateOpAdaptor::FNegateOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FNegateOpAdaptor::FNegateOpAdaptor(FNegateOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FNegateOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FNegateOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FNegateOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult FNegateOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FNegateOp::getOperationName() {
  return "spv.FNegate";
}

std::pair<unsigned, unsigned> FNegateOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FNegateOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FNegateOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange FNegateOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FNegateOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FNegateOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FNegateOp::result() {
  return *getODSResults(0).begin();
}

void FNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void FNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FNegateOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void FNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes({operand.getType()});

}

void FNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult FNegateOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseUnaryOp(parser, result);
}

void FNegateOp::print(::mlir::OpAsmPrinter &p) {
  return ::printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult FNegateOp::verify() {
  if (failed(FNegateOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FNegateOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FOrdEqualOp definitions
//===----------------------------------------------------------------------===//

FOrdEqualOpAdaptor::FOrdEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FOrdEqualOpAdaptor::FOrdEqualOpAdaptor(FOrdEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FOrdEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FOrdEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FOrdEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FOrdEqualOp::getOperationName() {
  return "spv.FOrdEqual";
}

std::pair<unsigned, unsigned> FOrdEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FOrdEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FOrdEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FOrdEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FOrdEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FOrdEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdEqualOp::result() {
  return *getODSResults(0).begin();
}

void FOrdEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FOrdEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FOrdEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FOrdEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FOrdEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FOrdEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FOrdEqualOp::verify() {
  if (failed(FOrdEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FOrdEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FOrdGreaterThanEqualOp definitions
//===----------------------------------------------------------------------===//

FOrdGreaterThanEqualOpAdaptor::FOrdGreaterThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FOrdGreaterThanEqualOpAdaptor::FOrdGreaterThanEqualOpAdaptor(FOrdGreaterThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FOrdGreaterThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FOrdGreaterThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdGreaterThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdGreaterThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FOrdGreaterThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FOrdGreaterThanEqualOp::getOperationName() {
  return "spv.FOrdGreaterThanEqual";
}

std::pair<unsigned, unsigned> FOrdGreaterThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FOrdGreaterThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdGreaterThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdGreaterThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FOrdGreaterThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FOrdGreaterThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FOrdGreaterThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FOrdGreaterThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdGreaterThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void FOrdGreaterThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FOrdGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FOrdGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FOrdGreaterThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FOrdGreaterThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FOrdGreaterThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FOrdGreaterThanEqualOp::verify() {
  if (failed(FOrdGreaterThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FOrdGreaterThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FOrdGreaterThanOp definitions
//===----------------------------------------------------------------------===//

FOrdGreaterThanOpAdaptor::FOrdGreaterThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FOrdGreaterThanOpAdaptor::FOrdGreaterThanOpAdaptor(FOrdGreaterThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FOrdGreaterThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FOrdGreaterThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdGreaterThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdGreaterThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FOrdGreaterThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FOrdGreaterThanOp::getOperationName() {
  return "spv.FOrdGreaterThan";
}

std::pair<unsigned, unsigned> FOrdGreaterThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FOrdGreaterThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdGreaterThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdGreaterThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FOrdGreaterThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FOrdGreaterThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FOrdGreaterThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FOrdGreaterThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdGreaterThanOp::result() {
  return *getODSResults(0).begin();
}

void FOrdGreaterThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FOrdGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FOrdGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FOrdGreaterThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FOrdGreaterThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FOrdGreaterThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FOrdGreaterThanOp::verify() {
  if (failed(FOrdGreaterThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FOrdGreaterThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FOrdLessThanEqualOp definitions
//===----------------------------------------------------------------------===//

FOrdLessThanEqualOpAdaptor::FOrdLessThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FOrdLessThanEqualOpAdaptor::FOrdLessThanEqualOpAdaptor(FOrdLessThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FOrdLessThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FOrdLessThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdLessThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdLessThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FOrdLessThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FOrdLessThanEqualOp::getOperationName() {
  return "spv.FOrdLessThanEqual";
}

std::pair<unsigned, unsigned> FOrdLessThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FOrdLessThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdLessThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdLessThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FOrdLessThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FOrdLessThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FOrdLessThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FOrdLessThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdLessThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void FOrdLessThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FOrdLessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FOrdLessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FOrdLessThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FOrdLessThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FOrdLessThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FOrdLessThanEqualOp::verify() {
  if (failed(FOrdLessThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FOrdLessThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FOrdLessThanOp definitions
//===----------------------------------------------------------------------===//

FOrdLessThanOpAdaptor::FOrdLessThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FOrdLessThanOpAdaptor::FOrdLessThanOpAdaptor(FOrdLessThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FOrdLessThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FOrdLessThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdLessThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdLessThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FOrdLessThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FOrdLessThanOp::getOperationName() {
  return "spv.FOrdLessThan";
}

std::pair<unsigned, unsigned> FOrdLessThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FOrdLessThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdLessThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdLessThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FOrdLessThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FOrdLessThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FOrdLessThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FOrdLessThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdLessThanOp::result() {
  return *getODSResults(0).begin();
}

void FOrdLessThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FOrdLessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FOrdLessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FOrdLessThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FOrdLessThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FOrdLessThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FOrdLessThanOp::verify() {
  if (failed(FOrdLessThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FOrdLessThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FOrdNotEqualOp definitions
//===----------------------------------------------------------------------===//

FOrdNotEqualOpAdaptor::FOrdNotEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FOrdNotEqualOpAdaptor::FOrdNotEqualOpAdaptor(FOrdNotEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FOrdNotEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FOrdNotEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdNotEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdNotEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FOrdNotEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FOrdNotEqualOp::getOperationName() {
  return "spv.FOrdNotEqual";
}

std::pair<unsigned, unsigned> FOrdNotEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FOrdNotEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdNotEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FOrdNotEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FOrdNotEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FOrdNotEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FOrdNotEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FOrdNotEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FOrdNotEqualOp::result() {
  return *getODSResults(0).begin();
}

void FOrdNotEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FOrdNotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FOrdNotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FOrdNotEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FOrdNotEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FOrdNotEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FOrdNotEqualOp::verify() {
  if (failed(FOrdNotEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FOrdNotEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FRemOp definitions
//===----------------------------------------------------------------------===//

FRemOpAdaptor::FRemOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FRemOpAdaptor::FRemOpAdaptor(FRemOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FRemOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FRemOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FRemOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FRemOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FRemOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FRemOp::getOperationName() {
  return "spv.FRem";
}

std::pair<unsigned, unsigned> FRemOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FRemOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FRemOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FRemOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FRemOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FRemOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FRemOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FRemOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FRemOp::result() {
  return *getODSResults(0).begin();
}

void FRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FRemOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void FRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void FRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult FRemOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void FRemOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult FRemOp::verify() {
  if (failed(FRemOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FRemOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FSubOp definitions
//===----------------------------------------------------------------------===//

FSubOpAdaptor::FSubOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FSubOpAdaptor::FSubOpAdaptor(FSubOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FSubOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FSubOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FSubOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FSubOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FSubOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FSubOp::getOperationName() {
  return "spv.FSub";
}

std::pair<unsigned, unsigned> FSubOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FSubOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FSubOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FSubOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FSubOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FSubOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FSubOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FSubOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FSubOp::result() {
  return *getODSResults(0).begin();
}

void FSubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FSubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FSubOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void FSubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void FSubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult FSubOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void FSubOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult FSubOp::verify() {
  if (failed(FSubOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF16())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF32())) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isF64())))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4 or Cooperative Matrix of 16/32/64-bit float values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FSubOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FUnordEqualOp definitions
//===----------------------------------------------------------------------===//

FUnordEqualOpAdaptor::FUnordEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FUnordEqualOpAdaptor::FUnordEqualOpAdaptor(FUnordEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FUnordEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FUnordEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FUnordEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FUnordEqualOp::getOperationName() {
  return "spv.FUnordEqual";
}

std::pair<unsigned, unsigned> FUnordEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FUnordEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FUnordEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FUnordEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FUnordEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FUnordEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordEqualOp::result() {
  return *getODSResults(0).begin();
}

void FUnordEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FUnordEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FUnordEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FUnordEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FUnordEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FUnordEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FUnordEqualOp::verify() {
  if (failed(FUnordEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FUnordEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FUnordGreaterThanEqualOp definitions
//===----------------------------------------------------------------------===//

FUnordGreaterThanEqualOpAdaptor::FUnordGreaterThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FUnordGreaterThanEqualOpAdaptor::FUnordGreaterThanEqualOpAdaptor(FUnordGreaterThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FUnordGreaterThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FUnordGreaterThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordGreaterThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordGreaterThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FUnordGreaterThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FUnordGreaterThanEqualOp::getOperationName() {
  return "spv.FUnordGreaterThanEqual";
}

std::pair<unsigned, unsigned> FUnordGreaterThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FUnordGreaterThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordGreaterThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordGreaterThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FUnordGreaterThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FUnordGreaterThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FUnordGreaterThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FUnordGreaterThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordGreaterThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void FUnordGreaterThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FUnordGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FUnordGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FUnordGreaterThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FUnordGreaterThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FUnordGreaterThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FUnordGreaterThanEqualOp::verify() {
  if (failed(FUnordGreaterThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FUnordGreaterThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FUnordGreaterThanOp definitions
//===----------------------------------------------------------------------===//

FUnordGreaterThanOpAdaptor::FUnordGreaterThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FUnordGreaterThanOpAdaptor::FUnordGreaterThanOpAdaptor(FUnordGreaterThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FUnordGreaterThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FUnordGreaterThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordGreaterThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordGreaterThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FUnordGreaterThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FUnordGreaterThanOp::getOperationName() {
  return "spv.FUnordGreaterThan";
}

std::pair<unsigned, unsigned> FUnordGreaterThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FUnordGreaterThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordGreaterThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordGreaterThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FUnordGreaterThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FUnordGreaterThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FUnordGreaterThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FUnordGreaterThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordGreaterThanOp::result() {
  return *getODSResults(0).begin();
}

void FUnordGreaterThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FUnordGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FUnordGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FUnordGreaterThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FUnordGreaterThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FUnordGreaterThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FUnordGreaterThanOp::verify() {
  if (failed(FUnordGreaterThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FUnordGreaterThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FUnordLessThanEqualOp definitions
//===----------------------------------------------------------------------===//

FUnordLessThanEqualOpAdaptor::FUnordLessThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FUnordLessThanEqualOpAdaptor::FUnordLessThanEqualOpAdaptor(FUnordLessThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FUnordLessThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FUnordLessThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordLessThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordLessThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FUnordLessThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FUnordLessThanEqualOp::getOperationName() {
  return "spv.FUnordLessThanEqual";
}

std::pair<unsigned, unsigned> FUnordLessThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FUnordLessThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordLessThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordLessThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FUnordLessThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FUnordLessThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FUnordLessThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FUnordLessThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordLessThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void FUnordLessThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FUnordLessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FUnordLessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FUnordLessThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FUnordLessThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FUnordLessThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FUnordLessThanEqualOp::verify() {
  if (failed(FUnordLessThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FUnordLessThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FUnordLessThanOp definitions
//===----------------------------------------------------------------------===//

FUnordLessThanOpAdaptor::FUnordLessThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FUnordLessThanOpAdaptor::FUnordLessThanOpAdaptor(FUnordLessThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FUnordLessThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FUnordLessThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordLessThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordLessThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FUnordLessThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FUnordLessThanOp::getOperationName() {
  return "spv.FUnordLessThan";
}

std::pair<unsigned, unsigned> FUnordLessThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FUnordLessThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordLessThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordLessThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FUnordLessThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FUnordLessThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FUnordLessThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FUnordLessThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordLessThanOp::result() {
  return *getODSResults(0).begin();
}

void FUnordLessThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FUnordLessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FUnordLessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FUnordLessThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FUnordLessThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FUnordLessThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FUnordLessThanOp::verify() {
  if (failed(FUnordLessThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FUnordLessThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FUnordNotEqualOp definitions
//===----------------------------------------------------------------------===//

FUnordNotEqualOpAdaptor::FUnordNotEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FUnordNotEqualOpAdaptor::FUnordNotEqualOpAdaptor(FUnordNotEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FUnordNotEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FUnordNotEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordNotEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordNotEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult FUnordNotEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef FUnordNotEqualOp::getOperationName() {
  return "spv.FUnordNotEqual";
}

std::pair<unsigned, unsigned> FUnordNotEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FUnordNotEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordNotEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value FUnordNotEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange FUnordNotEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange FUnordNotEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FUnordNotEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FUnordNotEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FUnordNotEqualOp::result() {
  return *getODSResults(0).begin();
}

void FUnordNotEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void FUnordNotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void FUnordNotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FUnordNotEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FUnordNotEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void FUnordNotEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult FUnordNotEqualOp::verify() {
  if (failed(FUnordNotEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void FUnordNotEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::FuncOp definitions
//===----------------------------------------------------------------------===//

FuncOpAdaptor::FuncOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FuncOpAdaptor::FuncOpAdaptor(FuncOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FuncOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange FuncOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::TypeAttr FuncOpAdaptor::type() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::TypeAttr attr = odsAttrs.get("type").cast<::mlir::TypeAttr>();
  return attr;
}

::mlir::StringAttr FuncOpAdaptor::sym_name() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::StringAttr attr = odsAttrs.get("sym_name").cast<::mlir::StringAttr>();
  return attr;
}

::mlir::IntegerAttr FuncOpAdaptor::function_control() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("function_control").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult FuncOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_type = odsAttrs.get("type");
  if (!tblgen_type) return emitError(loc, "'spv.func' op ""requires attribute 'type'");
    if (!(((tblgen_type.isa<::mlir::TypeAttr>())) && ((tblgen_type.cast<::mlir::TypeAttr>().getValue().isa<::mlir::Type>())))) return emitError(loc, "'spv.func' op ""attribute 'type' failed to satisfy constraint: any type attribute");
  }
  {
  auto tblgen_sym_name = odsAttrs.get("sym_name");
  if (!tblgen_sym_name) return emitError(loc, "'spv.func' op ""requires attribute 'sym_name'");
    if (!((tblgen_sym_name.isa<::mlir::StringAttr>()))) return emitError(loc, "'spv.func' op ""attribute 'sym_name' failed to satisfy constraint: string attribute");
  }
  {
  auto tblgen_function_control = odsAttrs.get("function_control");
  if (!tblgen_function_control) return emitError(loc, "'spv.func' op ""requires attribute 'function_control'");
    if (!((((tblgen_function_control.isa<::mlir::IntegerAttr>())) && ((tblgen_function_control.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeFunctionControl(tblgen_function_control.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.func' op ""attribute 'function_control' failed to satisfy constraint: valid SPIR-V FunctionControl");
  }
  return success();
}

::llvm::StringRef FuncOp::getOperationName() {
  return "spv.func";
}

std::pair<unsigned, unsigned> FuncOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range FuncOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> FuncOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range FuncOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Region &FuncOp::body() {
  return this->getOperation()->getRegion(0);
}

::mlir::TypeAttr FuncOp::typeAttr() {
  return this->getAttr("type").cast<::mlir::TypeAttr>();
}

::mlir::Type FuncOp::type() {
  auto attr = typeAttr();
  return attr.getValue().cast<::mlir::Type>();
}

::mlir::StringAttr FuncOp::sym_nameAttr() {
  return this->getAttr("sym_name").cast<::mlir::StringAttr>();
}

::llvm::StringRef FuncOp::sym_name() {
  auto attr = sym_nameAttr();
  return attr.getValue();
}

::mlir::IntegerAttr FuncOp::function_controlAttr() {
  return this->getAttr("function_control").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::FunctionControl FuncOp::function_control() {
  auto attr = function_controlAttr();
  return static_cast<::mlir::spirv::FunctionControl>(attr.getInt());
}

void FuncOp::typeAttr(::mlir::TypeAttr attr) {
  this->getOperation()->setAttr("type", attr);
}

void FuncOp::sym_nameAttr(::mlir::StringAttr attr) {
  this->getOperation()->setAttr("sym_name", attr);
}

void FuncOp::function_controlAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("function_control", attr);
}



void FuncOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeAttr type, ::mlir::StringAttr sym_name, ::mlir::IntegerAttr function_control) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", sym_name);
  odsState.addAttribute("function_control", function_control);
  (void)odsState.addRegion();
}

void FuncOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::TypeAttr type, ::mlir::StringAttr sym_name, ::mlir::IntegerAttr function_control) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", sym_name);
  odsState.addAttribute("function_control", function_control);
  (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FuncOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeAttr type, ::llvm::StringRef sym_name, ::mlir::spirv::FunctionControl function_control) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", odsBuilder.getStringAttr(sym_name));
  odsState.addAttribute("function_control", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(function_control)));
  (void)odsState.addRegion();
}

void FuncOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::TypeAttr type, ::llvm::StringRef sym_name, ::mlir::spirv::FunctionControl function_control) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", odsBuilder.getStringAttr(sym_name));
  odsState.addAttribute("function_control", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(function_control)));
  (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void FuncOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  for (unsigned i = 0; i != 1; ++i)
    (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult FuncOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseFuncOp(parser, result);
}

void FuncOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult FuncOp::verify() {
  if (failed(FuncOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isDirectInModuleLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a module-like op's block");
{
    unsigned index = 0; (void)index;
    for (::mlir::Region &region : ::mlir::MutableArrayRef<::mlir::Region>(this->getOperation()->getRegion(0))) {
      (void)region;
      if (!((true))) {
        return emitOpError("region #") << index << " ('body') failed to verify constraint: any region";
      }
      ++index;
    }
  }
  return success();
}














//===----------------------------------------------------------------------===//
// spirv::FunctionCallOp definitions
//===----------------------------------------------------------------------===//

FunctionCallOpAdaptor::FunctionCallOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

FunctionCallOpAdaptor::FunctionCallOpAdaptor(FunctionCallOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> FunctionCallOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange FunctionCallOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::ValueRange FunctionCallOpAdaptor::arguments() {
  return getODSOperands(0);
}

::mlir::FlatSymbolRefAttr FunctionCallOpAdaptor::callee() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::FlatSymbolRefAttr attr = odsAttrs.get("callee").cast<::mlir::FlatSymbolRefAttr>();
  return attr;
}

::mlir::LogicalResult FunctionCallOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_callee = odsAttrs.get("callee");
  if (!tblgen_callee) return emitError(loc, "'spv.FunctionCall' op ""requires attribute 'callee'");
    if (!((tblgen_callee.isa<::mlir::FlatSymbolRefAttr>()))) return emitError(loc, "'spv.FunctionCall' op ""attribute 'callee' failed to satisfy constraint: flat symbol reference attribute");
  }
  return success();
}

::llvm::StringRef FunctionCallOp::getOperationName() {
  return "spv.FunctionCall";
}

std::pair<unsigned, unsigned> FunctionCallOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range FunctionCallOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Operation::operand_range FunctionCallOp::arguments() {
  return getODSOperands(0);
}

::mlir::MutableOperandRange FunctionCallOp::argumentsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> FunctionCallOp::getODSResultIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumResults() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::result_range FunctionCallOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value FunctionCallOp::result() {
  auto results = getODSResults(0);
  return results.empty() ? ::mlir::Value() : *results.begin();
}

::mlir::FlatSymbolRefAttr FunctionCallOp::calleeAttr() {
  return this->getAttr("callee").cast<::mlir::FlatSymbolRefAttr>();
}

::llvm::StringRef FunctionCallOp::callee() {
  auto attr = calleeAttr();
  return attr.getValue();
}

void FunctionCallOp::calleeAttr(::mlir::FlatSymbolRefAttr attr) {
  this->getOperation()->setAttr("callee", attr);
}

void FunctionCallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange arguments) {
  odsState.addOperands(arguments);
  odsState.addAttribute("callee", callee);
  if (result)
    odsState.addTypes(result);
}

void FunctionCallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange arguments) {
  odsState.addOperands(arguments);
  odsState.addAttribute("callee", callee);
  odsState.addTypes(resultTypes);
}

void FunctionCallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, ::llvm::StringRef callee, ::mlir::ValueRange arguments) {
  odsState.addOperands(arguments);
  odsState.addAttribute("callee", odsBuilder.getSymbolRefAttr(callee));
  if (result)
    odsState.addTypes(result);
}

void FunctionCallOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::llvm::StringRef callee, ::mlir::ValueRange arguments) {
  odsState.addOperands(arguments);
  odsState.addAttribute("callee", odsBuilder.getSymbolRefAttr(callee));
  odsState.addTypes(resultTypes);
}

void FunctionCallOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult FunctionCallOp::verify() {
  if (failed(FunctionCallOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    if (valueGroup0.size() > 1)
      return emitOpError("result group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup0.size();
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
  return ::verify(*this);
}













::mlir::ParseResult FunctionCallOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> argumentsOperands;
  ::llvm::SMLoc argumentsOperandsLoc = parser.getCurrentLocation();
  (void)argumentsOperandsLoc;
  ::llvm::ArrayRef<::mlir::Type> argumentsTypes;
  ::llvm::ArrayRef<::mlir::Type> allResultTypes;

  ::mlir::FlatSymbolRefAttr calleeAttr;
  if (parser.parseAttribute(calleeAttr, parser.getBuilder().getType<::mlir::NoneType>(), "callee", result.attributes))
    return failure();
  if (parser.parseLParen())
    return failure();

  if (parser.parseOperandList(argumentsOperands))
    return failure();
  if (parser.parseRParen())
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  ::mlir::FunctionType arguments__allResult_functionType;
  if (parser.parseType(arguments__allResult_functionType))
    return failure();
  argumentsTypes = arguments__allResult_functionType.getInputs();
  allResultTypes = arguments__allResult_functionType.getResults();
  result.addTypes(allResultTypes);
  if (parser.resolveOperands(argumentsOperands, argumentsTypes, argumentsOperandsLoc, result.operands))
    return failure();
  return success();
}

void FunctionCallOp::print(OpAsmPrinter &p) {
  p << "spv.FunctionCall";
  p << " ";
  p.printAttributeWithoutType(calleeAttr());
  p << "(";
  p << arguments();
  p << ")";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"callee"});
  p << " " << ":";
  p << " ";
  p.printFunctionalType(arguments().getTypes(), getOperation()->getResultTypes());
}


//===----------------------------------------------------------------------===//
// spirv::GLSLCeilOp definitions
//===----------------------------------------------------------------------===//

GLSLCeilOpAdaptor::GLSLCeilOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLCeilOpAdaptor::GLSLCeilOpAdaptor(GLSLCeilOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLCeilOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLCeilOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLCeilOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLCeilOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLCeilOp::getOperationName() {
  return "spv.GLSL.Ceil";
}

std::pair<unsigned, unsigned> GLSLCeilOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLCeilOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLCeilOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLCeilOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLCeilOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLCeilOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLCeilOp::result() {
  return *getODSResults(0).begin();
}

void GLSLCeilOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLCeilOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLCeilOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLCeilOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLCeilOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLCeilOp::verify() {
  if (failed(GLSLCeilOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLCeilOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLCosOp definitions
//===----------------------------------------------------------------------===//

GLSLCosOpAdaptor::GLSLCosOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLCosOpAdaptor::GLSLCosOpAdaptor(GLSLCosOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLCosOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLCosOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLCosOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLCosOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLCosOp::getOperationName() {
  return "spv.GLSL.Cos";
}

std::pair<unsigned, unsigned> GLSLCosOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLCosOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLCosOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLCosOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLCosOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLCosOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLCosOp::result() {
  return *getODSResults(0).begin();
}

void GLSLCosOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLCosOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLCosOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLCosOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLCosOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLCosOp::verify() {
  if (failed(GLSLCosOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLCosOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLExpOp definitions
//===----------------------------------------------------------------------===//

GLSLExpOpAdaptor::GLSLExpOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLExpOpAdaptor::GLSLExpOpAdaptor(GLSLExpOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLExpOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLExpOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLExpOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLExpOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLExpOp::getOperationName() {
  return "spv.GLSL.Exp";
}

std::pair<unsigned, unsigned> GLSLExpOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLExpOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLExpOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLExpOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLExpOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLExpOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLExpOp::result() {
  return *getODSResults(0).begin();
}

void GLSLExpOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLExpOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLExpOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLExpOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLExpOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLExpOp::verify() {
  if (failed(GLSLExpOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLExpOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLFAbsOp definitions
//===----------------------------------------------------------------------===//

GLSLFAbsOpAdaptor::GLSLFAbsOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLFAbsOpAdaptor::GLSLFAbsOpAdaptor(GLSLFAbsOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLFAbsOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLFAbsOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFAbsOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLFAbsOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLFAbsOp::getOperationName() {
  return "spv.GLSL.FAbs";
}

std::pair<unsigned, unsigned> GLSLFAbsOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLFAbsOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFAbsOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLFAbsOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLFAbsOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLFAbsOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFAbsOp::result() {
  return *getODSResults(0).begin();
}

void GLSLFAbsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLFAbsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLFAbsOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLFAbsOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLFAbsOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLFAbsOp::verify() {
  if (failed(GLSLFAbsOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLFAbsOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLFMaxOp definitions
//===----------------------------------------------------------------------===//

GLSLFMaxOpAdaptor::GLSLFMaxOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLFMaxOpAdaptor::GLSLFMaxOpAdaptor(GLSLFMaxOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLFMaxOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLFMaxOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFMaxOpAdaptor::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLFMaxOpAdaptor::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult GLSLFMaxOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLFMaxOp::getOperationName() {
  return "spv.GLSL.FMax";
}

std::pair<unsigned, unsigned> GLSLFMaxOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLFMaxOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFMaxOp::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLFMaxOp::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange GLSLFMaxOp::lhsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GLSLFMaxOp::rhsMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLFMaxOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLFMaxOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFMaxOp::result() {
  return *getODSResults(0).begin();
}

void GLSLFMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  odsState.addTypes(result);
}

void GLSLFMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLFMaxOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLFMaxOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void GLSLFMaxOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult GLSLFMaxOp::verify() {
  if (failed(GLSLFMaxOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLFMaxOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLFMinOp definitions
//===----------------------------------------------------------------------===//

GLSLFMinOpAdaptor::GLSLFMinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLFMinOpAdaptor::GLSLFMinOpAdaptor(GLSLFMinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLFMinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLFMinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFMinOpAdaptor::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLFMinOpAdaptor::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult GLSLFMinOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLFMinOp::getOperationName() {
  return "spv.GLSL.FMin";
}

std::pair<unsigned, unsigned> GLSLFMinOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLFMinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFMinOp::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLFMinOp::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange GLSLFMinOp::lhsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GLSLFMinOp::rhsMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLFMinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLFMinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFMinOp::result() {
  return *getODSResults(0).begin();
}

void GLSLFMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  odsState.addTypes(result);
}

void GLSLFMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLFMinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLFMinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void GLSLFMinOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult GLSLFMinOp::verify() {
  if (failed(GLSLFMinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLFMinOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLFSignOp definitions
//===----------------------------------------------------------------------===//

GLSLFSignOpAdaptor::GLSLFSignOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLFSignOpAdaptor::GLSLFSignOpAdaptor(GLSLFSignOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLFSignOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLFSignOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFSignOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLFSignOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLFSignOp::getOperationName() {
  return "spv.GLSL.FSign";
}

std::pair<unsigned, unsigned> GLSLFSignOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLFSignOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFSignOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLFSignOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLFSignOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLFSignOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFSignOp::result() {
  return *getODSResults(0).begin();
}

void GLSLFSignOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLFSignOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLFSignOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLFSignOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLFSignOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLFSignOp::verify() {
  if (failed(GLSLFSignOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLFSignOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLFloorOp definitions
//===----------------------------------------------------------------------===//

GLSLFloorOpAdaptor::GLSLFloorOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLFloorOpAdaptor::GLSLFloorOpAdaptor(GLSLFloorOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLFloorOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLFloorOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFloorOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLFloorOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLFloorOp::getOperationName() {
  return "spv.GLSL.Floor";
}

std::pair<unsigned, unsigned> GLSLFloorOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLFloorOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFloorOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLFloorOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLFloorOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLFloorOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLFloorOp::result() {
  return *getODSResults(0).begin();
}

void GLSLFloorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLFloorOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLFloorOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLFloorOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLFloorOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLFloorOp::verify() {
  if (failed(GLSLFloorOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLFloorOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLInverseSqrtOp definitions
//===----------------------------------------------------------------------===//

GLSLInverseSqrtOpAdaptor::GLSLInverseSqrtOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLInverseSqrtOpAdaptor::GLSLInverseSqrtOpAdaptor(GLSLInverseSqrtOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLInverseSqrtOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLInverseSqrtOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLInverseSqrtOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLInverseSqrtOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLInverseSqrtOp::getOperationName() {
  return "spv.GLSL.InverseSqrt";
}

std::pair<unsigned, unsigned> GLSLInverseSqrtOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLInverseSqrtOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLInverseSqrtOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLInverseSqrtOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLInverseSqrtOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLInverseSqrtOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLInverseSqrtOp::result() {
  return *getODSResults(0).begin();
}

void GLSLInverseSqrtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLInverseSqrtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLInverseSqrtOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLInverseSqrtOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLInverseSqrtOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLInverseSqrtOp::verify() {
  if (failed(GLSLInverseSqrtOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLInverseSqrtOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLLogOp definitions
//===----------------------------------------------------------------------===//

GLSLLogOpAdaptor::GLSLLogOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLLogOpAdaptor::GLSLLogOpAdaptor(GLSLLogOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLLogOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLLogOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLLogOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLLogOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLLogOp::getOperationName() {
  return "spv.GLSL.Log";
}

std::pair<unsigned, unsigned> GLSLLogOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLLogOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLLogOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLLogOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLLogOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLLogOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLLogOp::result() {
  return *getODSResults(0).begin();
}

void GLSLLogOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLLogOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLLogOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLLogOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLLogOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLLogOp::verify() {
  if (failed(GLSLLogOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLLogOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLSAbsOp definitions
//===----------------------------------------------------------------------===//

GLSLSAbsOpAdaptor::GLSLSAbsOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLSAbsOpAdaptor::GLSLSAbsOpAdaptor(GLSLSAbsOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLSAbsOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLSAbsOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSAbsOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLSAbsOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLSAbsOp::getOperationName() {
  return "spv.GLSL.SAbs";
}

std::pair<unsigned, unsigned> GLSLSAbsOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLSAbsOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSAbsOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLSAbsOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLSAbsOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLSAbsOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSAbsOp::result() {
  return *getODSResults(0).begin();
}

void GLSLSAbsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLSAbsOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLSAbsOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLSAbsOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLSAbsOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLSAbsOp::verify() {
  if (failed(GLSLSAbsOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLSAbsOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLSMaxOp definitions
//===----------------------------------------------------------------------===//

GLSLSMaxOpAdaptor::GLSLSMaxOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLSMaxOpAdaptor::GLSLSMaxOpAdaptor(GLSLSMaxOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLSMaxOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLSMaxOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSMaxOpAdaptor::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLSMaxOpAdaptor::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult GLSLSMaxOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLSMaxOp::getOperationName() {
  return "spv.GLSL.SMax";
}

std::pair<unsigned, unsigned> GLSLSMaxOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLSMaxOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSMaxOp::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLSMaxOp::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange GLSLSMaxOp::lhsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GLSLSMaxOp::rhsMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLSMaxOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLSMaxOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSMaxOp::result() {
  return *getODSResults(0).begin();
}

void GLSLSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  odsState.addTypes(result);
}

void GLSLSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLSMaxOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLSMaxOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void GLSLSMaxOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult GLSLSMaxOp::verify() {
  if (failed(GLSLSMaxOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLSMaxOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLSMinOp definitions
//===----------------------------------------------------------------------===//

GLSLSMinOpAdaptor::GLSLSMinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLSMinOpAdaptor::GLSLSMinOpAdaptor(GLSLSMinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLSMinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLSMinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSMinOpAdaptor::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLSMinOpAdaptor::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult GLSLSMinOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLSMinOp::getOperationName() {
  return "spv.GLSL.SMin";
}

std::pair<unsigned, unsigned> GLSLSMinOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLSMinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSMinOp::lhs() {
  return *getODSOperands(0).begin();
}

::mlir::Value GLSLSMinOp::rhs() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange GLSLSMinOp::lhsMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GLSLSMinOp::rhsMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLSMinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLSMinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSMinOp::result() {
  return *getODSResults(0).begin();
}

void GLSLSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  odsState.addTypes(result);
}

void GLSLSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value lhs, ::mlir::Value rhs) {
  odsState.addOperands(lhs);
  odsState.addOperands(rhs);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLSMinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLSMinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void GLSLSMinOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult GLSLSMinOp::verify() {
  if (failed(GLSLSMinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLSMinOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLSSignOp definitions
//===----------------------------------------------------------------------===//

GLSLSSignOpAdaptor::GLSLSSignOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLSSignOpAdaptor::GLSLSSignOpAdaptor(GLSLSSignOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLSSignOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLSSignOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSSignOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLSSignOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLSSignOp::getOperationName() {
  return "spv.GLSL.SSign";
}

std::pair<unsigned, unsigned> GLSLSSignOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLSSignOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSSignOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLSSignOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLSSignOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLSSignOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSSignOp::result() {
  return *getODSResults(0).begin();
}

void GLSLSSignOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLSSignOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLSSignOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLSSignOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLSSignOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLSSignOp::verify() {
  if (failed(GLSLSSignOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLSSignOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLSinOp definitions
//===----------------------------------------------------------------------===//

GLSLSinOpAdaptor::GLSLSinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLSinOpAdaptor::GLSLSinOpAdaptor(GLSLSinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLSinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLSinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSinOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLSinOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLSinOp::getOperationName() {
  return "spv.GLSL.Sin";
}

std::pair<unsigned, unsigned> GLSLSinOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLSinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSinOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLSinOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLSinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLSinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSinOp::result() {
  return *getODSResults(0).begin();
}

void GLSLSinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLSinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLSinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLSinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLSinOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLSinOp::verify() {
  if (failed(GLSLSinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLSinOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLSqrtOp definitions
//===----------------------------------------------------------------------===//

GLSLSqrtOpAdaptor::GLSLSqrtOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLSqrtOpAdaptor::GLSLSqrtOpAdaptor(GLSLSqrtOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLSqrtOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLSqrtOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSqrtOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLSqrtOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLSqrtOp::getOperationName() {
  return "spv.GLSL.Sqrt";
}

std::pair<unsigned, unsigned> GLSLSqrtOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLSqrtOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSqrtOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLSqrtOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLSqrtOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLSqrtOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLSqrtOp::result() {
  return *getODSResults(0).begin();
}

void GLSLSqrtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLSqrtOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLSqrtOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLSqrtOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLSqrtOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLSqrtOp::verify() {
  if (failed(GLSLSqrtOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLSqrtOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLTanOp definitions
//===----------------------------------------------------------------------===//

GLSLTanOpAdaptor::GLSLTanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLTanOpAdaptor::GLSLTanOpAdaptor(GLSLTanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLTanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLTanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLTanOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLTanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLTanOp::getOperationName() {
  return "spv.GLSL.Tan";
}

std::pair<unsigned, unsigned> GLSLTanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLTanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLTanOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLTanOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLTanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLTanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLTanOp::result() {
  return *getODSResults(0).begin();
}

void GLSLTanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLTanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLTanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLTanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLTanOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLTanOp::verify() {
  if (failed(GLSLTanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLTanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GLSLTanhOp definitions
//===----------------------------------------------------------------------===//

GLSLTanhOpAdaptor::GLSLTanhOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GLSLTanhOpAdaptor::GLSLTanhOpAdaptor(GLSLTanhOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GLSLTanhOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GLSLTanhOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLTanhOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult GLSLTanhOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef GLSLTanhOp::getOperationName() {
  return "spv.GLSL.Tanh";
}

std::pair<unsigned, unsigned> GLSLTanhOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GLSLTanhOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLTanhOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GLSLTanhOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GLSLTanhOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GLSLTanhOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GLSLTanhOp::result() {
  return *getODSResults(0).begin();
}

void GLSLTanhOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void GLSLTanhOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GLSLTanhOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GLSLTanhOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseUnaryOp(parser, result);
}

void GLSLTanhOp::print(::mlir::OpAsmPrinter &p) {
  return printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult GLSLTanhOp::verify() {
  if (failed(GLSLTanhOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void GLSLTanhOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::GlobalVariableOp definitions
//===----------------------------------------------------------------------===//

GlobalVariableOpAdaptor::GlobalVariableOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GlobalVariableOpAdaptor::GlobalVariableOpAdaptor(GlobalVariableOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GlobalVariableOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GlobalVariableOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::TypeAttr GlobalVariableOpAdaptor::type() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::TypeAttr attr = odsAttrs.get("type").cast<::mlir::TypeAttr>();
  return attr;
}

::mlir::StringAttr GlobalVariableOpAdaptor::sym_name() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::StringAttr attr = odsAttrs.get("sym_name").cast<::mlir::StringAttr>();
  return attr;
}

::mlir::FlatSymbolRefAttr GlobalVariableOpAdaptor::initializer() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::FlatSymbolRefAttr attr = odsAttrs.get("initializer").dyn_cast_or_null<::mlir::FlatSymbolRefAttr>();
  return attr;
}

::mlir::LogicalResult GlobalVariableOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_type = odsAttrs.get("type");
  if (!tblgen_type) return emitError(loc, "'spv.globalVariable' op ""requires attribute 'type'");
    if (!(((tblgen_type.isa<::mlir::TypeAttr>())) && ((tblgen_type.cast<::mlir::TypeAttr>().getValue().isa<::mlir::Type>())))) return emitError(loc, "'spv.globalVariable' op ""attribute 'type' failed to satisfy constraint: any type attribute");
  }
  {
  auto tblgen_sym_name = odsAttrs.get("sym_name");
  if (!tblgen_sym_name) return emitError(loc, "'spv.globalVariable' op ""requires attribute 'sym_name'");
    if (!((tblgen_sym_name.isa<::mlir::StringAttr>()))) return emitError(loc, "'spv.globalVariable' op ""attribute 'sym_name' failed to satisfy constraint: string attribute");
  }
  {
  auto tblgen_initializer = odsAttrs.get("initializer");
  if (tblgen_initializer) {
    if (!((tblgen_initializer.isa<::mlir::FlatSymbolRefAttr>()))) return emitError(loc, "'spv.globalVariable' op ""attribute 'initializer' failed to satisfy constraint: flat symbol reference attribute");
  }
  }
  return success();
}

::llvm::StringRef GlobalVariableOp::getOperationName() {
  return "spv.globalVariable";
}

std::pair<unsigned, unsigned> GlobalVariableOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GlobalVariableOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> GlobalVariableOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GlobalVariableOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::TypeAttr GlobalVariableOp::typeAttr() {
  return this->getAttr("type").cast<::mlir::TypeAttr>();
}

::mlir::Type GlobalVariableOp::type() {
  auto attr = typeAttr();
  return attr.getValue().cast<::mlir::Type>();
}

::mlir::StringAttr GlobalVariableOp::sym_nameAttr() {
  return this->getAttr("sym_name").cast<::mlir::StringAttr>();
}

::llvm::StringRef GlobalVariableOp::sym_name() {
  auto attr = sym_nameAttr();
  return attr.getValue();
}

::mlir::FlatSymbolRefAttr GlobalVariableOp::initializerAttr() {
  return this->getAttr("initializer").dyn_cast_or_null<::mlir::FlatSymbolRefAttr>();
}

::llvm::Optional< ::llvm::StringRef > GlobalVariableOp::initializer() {
  auto attr = initializerAttr();
  return attr ? ::llvm::Optional< ::llvm::StringRef >(attr.getValue()) : (::llvm::None);
}

void GlobalVariableOp::typeAttr(::mlir::TypeAttr attr) {
  this->getOperation()->setAttr("type", attr);
}

void GlobalVariableOp::sym_nameAttr(::mlir::StringAttr attr) {
  this->getOperation()->setAttr("sym_name", attr);
}

void GlobalVariableOp::initializerAttr(::mlir::FlatSymbolRefAttr attr) {
  this->getOperation()->setAttr("initializer", attr);
}

void GlobalVariableOp::build(OpBuilder &builder, OperationState &state, TypeAttr type, ArrayRef<NamedAttribute> namedAttrs) {
      state.addAttribute("type", type);
      state.addAttributes(namedAttrs);
    
}





void GlobalVariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeAttr type, ::mlir::StringAttr sym_name, /*optional*/::mlir::FlatSymbolRefAttr initializer) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", sym_name);
  if (initializer) {
  odsState.addAttribute("initializer", initializer);
  }
}

void GlobalVariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::TypeAttr type, ::mlir::StringAttr sym_name, /*optional*/::mlir::FlatSymbolRefAttr initializer) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", sym_name);
  if (initializer) {
  odsState.addAttribute("initializer", initializer);
  }
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GlobalVariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeAttr type, ::llvm::StringRef sym_name, /*optional*/::mlir::FlatSymbolRefAttr initializer) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", odsBuilder.getStringAttr(sym_name));
  if (initializer) {
  odsState.addAttribute("initializer", initializer);
  }
}

void GlobalVariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::TypeAttr type, ::llvm::StringRef sym_name, /*optional*/::mlir::FlatSymbolRefAttr initializer) {
  odsState.addAttribute("type", type);
  odsState.addAttribute("sym_name", odsBuilder.getStringAttr(sym_name));
  if (initializer) {
  odsState.addAttribute("initializer", initializer);
  }
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GlobalVariableOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GlobalVariableOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseGlobalVariableOp(parser, result);
}

void GlobalVariableOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult GlobalVariableOp::verify() {
  if (failed(GlobalVariableOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isDirectInModuleLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a module-like op's block");
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformBallotOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformBallotOpAdaptor::GroupNonUniformBallotOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformBallotOpAdaptor::GroupNonUniformBallotOpAdaptor(GroupNonUniformBallotOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformBallotOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GroupNonUniformBallotOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformBallotOpAdaptor::predicate() {
  return *getODSOperands(0).begin();
}

::mlir::IntegerAttr GroupNonUniformBallotOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformBallotOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformBallot' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformBallot' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  return success();
}

::llvm::StringRef GroupNonUniformBallotOp::getOperationName() {
  return "spv.GroupNonUniformBallot";
}

std::pair<unsigned, unsigned> GroupNonUniformBallotOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GroupNonUniformBallotOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformBallotOp::predicate() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange GroupNonUniformBallotOp::predicateMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformBallotOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformBallotOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformBallotOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformBallotOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformBallotOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

void GroupNonUniformBallotOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformBallotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::Value predicate) {
  odsState.addOperands(predicate);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addTypes(result);
}

void GroupNonUniformBallotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::Value predicate) {
  odsState.addOperands(predicate);
  odsState.addAttribute("execution_scope", execution_scope);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformBallotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::Value predicate) {
  odsState.addOperands(predicate);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addTypes(result);
}

void GroupNonUniformBallotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::Value predicate) {
  odsState.addOperands(predicate);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformBallotOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult GroupNonUniformBallotOp::verify() {
  if (failed(GroupNonUniformBallotOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isSignlessInteger(1)))) {
        return emitOpError("operand #") << index << " must be bool, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isa<::mlir::VectorType>())) && ((((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isUnsignedInteger(8)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isUnsignedInteger(16)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isUnsignedInteger(32)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(64))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isUnsignedInteger(64)))))) && (((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) {
        return emitOpError("result #") << index << " must be vector of 8/16/32/64-bit signless/unsigned integer values of length 4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}









::mlir::ParseResult GroupNonUniformBallotOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::OpAsmParser::OperandType predicateRawOperands[1];
  ::llvm::ArrayRef<::mlir::OpAsmParser::OperandType> predicateOperands(predicateRawOperands);  ::llvm::SMLoc predicateOperandsLoc = parser.getCurrentLocation();
  (void)predicateOperandsLoc;
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

  {
    ::mlir::StringAttr attrVal;
    ::mlir::NamedAttrList attrStorage;
    auto loc = parser.getCurrentLocation();
    if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                              "execution_scope", attrStorage))
      return failure();

    auto attrOptional = ::mlir::spirv::symbolizeScope(attrVal.getValue());
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "execution_scope attribute specification: " << attrVal;

    result.addAttribute("execution_scope", parser.getBuilder().getI32IntegerAttr(static_cast<int32_t>(attrOptional.getValue())));
  }

  if (parser.parseOperand(predicateRawOperands[0]))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  ::mlir::Type odsBuildableType0 = parser.getBuilder().getIntegerType(1);
  result.addTypes(resultTypes);
  if (parser.resolveOperands(predicateOperands, odsBuildableType0, result.operands))
    return failure();
  return success();
}

void GroupNonUniformBallotOp::print(OpAsmPrinter &p) {
  p << "spv.GroupNonUniformBallot";
  p << " ";
  p << "\"" << stringifyScope(execution_scope()) << "\"";
  p << " ";
  p << predicate();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"execution_scope"});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}


//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformElectOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformElectOpAdaptor::GroupNonUniformElectOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformElectOpAdaptor::GroupNonUniformElectOpAdaptor(GroupNonUniformElectOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformElectOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange GroupNonUniformElectOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr GroupNonUniformElectOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformElectOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformElect' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformElect' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  return success();
}

::llvm::StringRef GroupNonUniformElectOp::getOperationName() {
  return "spv.GroupNonUniformElect";
}

std::pair<unsigned, unsigned> GroupNonUniformElectOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range GroupNonUniformElectOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> GroupNonUniformElectOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformElectOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformElectOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformElectOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformElectOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

void GroupNonUniformElectOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}



void GroupNonUniformElectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope) {
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addTypes(result);
}

void GroupNonUniformElectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope) {
  odsState.addAttribute("execution_scope", execution_scope);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformElectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope) {
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addTypes(result);
}

void GroupNonUniformElectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope) {
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformElectOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult GroupNonUniformElectOp::verify() {
  if (failed(GroupNonUniformElectOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isSignlessInteger(1)))) {
        return emitOpError("result #") << index << " must be bool, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}









::mlir::ParseResult GroupNonUniformElectOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

  {
    ::mlir::StringAttr attrVal;
    ::mlir::NamedAttrList attrStorage;
    auto loc = parser.getCurrentLocation();
    if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                              "execution_scope", attrStorage))
      return failure();

    auto attrOptional = ::mlir::spirv::symbolizeScope(attrVal.getValue());
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "execution_scope attribute specification: " << attrVal;

    result.addAttribute("execution_scope", parser.getBuilder().getI32IntegerAttr(static_cast<int32_t>(attrOptional.getValue())));
  }
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  result.addTypes(resultTypes);
  return success();
}

void GroupNonUniformElectOp::print(OpAsmPrinter &p) {
  p << "spv.GroupNonUniformElect";
  p << " ";
  p << "\"" << stringifyScope(execution_scope()) << "\"";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"execution_scope"});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}


//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformFAddOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformFAddOpAdaptor::GroupNonUniformFAddOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformFAddOpAdaptor::GroupNonUniformFAddOpAdaptor(GroupNonUniformFAddOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformFAddOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformFAddOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFAddOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFAddOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformFAddOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformFAddOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformFAddOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformFAdd' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFAdd' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformFAdd' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFAdd' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformFAddOp::getOperationName() {
  return "spv.GroupNonUniformFAdd";
}

std::pair<unsigned, unsigned> GroupNonUniformFAddOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformFAddOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFAddOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFAddOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformFAddOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformFAddOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformFAddOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformFAddOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFAddOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformFAddOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformFAddOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformFAddOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformFAddOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformFAddOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformFAddOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformFAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformFAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformFAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFAddOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformFAddOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformFAddOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformFAddOp::verify() {
  if (failed(GroupNonUniformFAddOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformFMaxOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformFMaxOpAdaptor::GroupNonUniformFMaxOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformFMaxOpAdaptor::GroupNonUniformFMaxOpAdaptor(GroupNonUniformFMaxOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformFMaxOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformFMaxOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMaxOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFMaxOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformFMaxOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformFMaxOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformFMaxOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformFMax' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFMax' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformFMax' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFMax' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformFMaxOp::getOperationName() {
  return "spv.GroupNonUniformFMax";
}

std::pair<unsigned, unsigned> GroupNonUniformFMaxOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformFMaxOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMaxOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFMaxOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformFMaxOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformFMaxOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformFMaxOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformFMaxOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMaxOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformFMaxOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformFMaxOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformFMaxOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformFMaxOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformFMaxOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformFMaxOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformFMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformFMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformFMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFMaxOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformFMaxOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformFMaxOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformFMaxOp::verify() {
  if (failed(GroupNonUniformFMaxOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformFMinOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformFMinOpAdaptor::GroupNonUniformFMinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformFMinOpAdaptor::GroupNonUniformFMinOpAdaptor(GroupNonUniformFMinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformFMinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformFMinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMinOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFMinOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformFMinOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformFMinOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformFMinOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformFMin' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFMin' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformFMin' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFMin' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformFMinOp::getOperationName() {
  return "spv.GroupNonUniformFMin";
}

std::pair<unsigned, unsigned> GroupNonUniformFMinOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformFMinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMinOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFMinOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformFMinOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformFMinOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformFMinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformFMinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMinOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformFMinOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformFMinOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformFMinOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformFMinOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformFMinOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformFMinOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformFMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformFMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformFMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFMinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformFMinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformFMinOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformFMinOp::verify() {
  if (failed(GroupNonUniformFMinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformFMulOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformFMulOpAdaptor::GroupNonUniformFMulOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformFMulOpAdaptor::GroupNonUniformFMulOpAdaptor(GroupNonUniformFMulOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformFMulOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformFMulOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMulOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFMulOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformFMulOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformFMulOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformFMulOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformFMul' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFMul' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformFMul' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformFMul' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformFMulOp::getOperationName() {
  return "spv.GroupNonUniformFMul";
}

std::pair<unsigned, unsigned> GroupNonUniformFMulOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformFMulOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMulOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformFMulOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformFMulOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformFMulOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformFMulOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformFMulOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformFMulOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformFMulOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformFMulOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformFMulOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformFMulOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformFMulOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformFMulOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformFMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformFMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformFMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformFMulOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformFMulOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformFMulOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformFMulOp::verify() {
  if (failed(GroupNonUniformFMulOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64())))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformIAddOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformIAddOpAdaptor::GroupNonUniformIAddOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformIAddOpAdaptor::GroupNonUniformIAddOpAdaptor(GroupNonUniformIAddOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformIAddOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformIAddOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformIAddOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformIAddOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformIAddOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformIAddOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformIAddOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformIAdd' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformIAdd' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformIAdd' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformIAdd' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformIAddOp::getOperationName() {
  return "spv.GroupNonUniformIAdd";
}

std::pair<unsigned, unsigned> GroupNonUniformIAddOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformIAddOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformIAddOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformIAddOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformIAddOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformIAddOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformIAddOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformIAddOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformIAddOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformIAddOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformIAddOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformIAddOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformIAddOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformIAddOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformIAddOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformIAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformIAddOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformIAddOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformIAddOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformIAddOp::verify() {
  if (failed(GroupNonUniformIAddOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformIMulOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformIMulOpAdaptor::GroupNonUniformIMulOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformIMulOpAdaptor::GroupNonUniformIMulOpAdaptor(GroupNonUniformIMulOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformIMulOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformIMulOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformIMulOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformIMulOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformIMulOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformIMulOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformIMulOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformIMul' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformIMul' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformIMul' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformIMul' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformIMulOp::getOperationName() {
  return "spv.GroupNonUniformIMul";
}

std::pair<unsigned, unsigned> GroupNonUniformIMulOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformIMulOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformIMulOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformIMulOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformIMulOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformIMulOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformIMulOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformIMulOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformIMulOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformIMulOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformIMulOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformIMulOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformIMulOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformIMulOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformIMulOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformIMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformIMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformIMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformIMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformIMulOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformIMulOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformIMulOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformIMulOp::verify() {
  if (failed(GroupNonUniformIMulOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformSMaxOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformSMaxOpAdaptor::GroupNonUniformSMaxOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformSMaxOpAdaptor::GroupNonUniformSMaxOpAdaptor(GroupNonUniformSMaxOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformSMaxOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformSMaxOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformSMaxOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformSMaxOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformSMaxOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformSMaxOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformSMaxOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformSMax' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformSMax' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformSMax' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformSMax' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformSMaxOp::getOperationName() {
  return "spv.GroupNonUniformSMax";
}

std::pair<unsigned, unsigned> GroupNonUniformSMaxOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformSMaxOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformSMaxOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformSMaxOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformSMaxOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformSMaxOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformSMaxOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformSMaxOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformSMaxOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformSMaxOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformSMaxOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformSMaxOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformSMaxOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformSMaxOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformSMaxOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformSMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformSMaxOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformSMaxOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformSMaxOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformSMaxOp::verify() {
  if (failed(GroupNonUniformSMaxOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformSMinOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformSMinOpAdaptor::GroupNonUniformSMinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformSMinOpAdaptor::GroupNonUniformSMinOpAdaptor(GroupNonUniformSMinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformSMinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformSMinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformSMinOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformSMinOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformSMinOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformSMinOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformSMinOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformSMin' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformSMin' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformSMin' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformSMin' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformSMinOp::getOperationName() {
  return "spv.GroupNonUniformSMin";
}

std::pair<unsigned, unsigned> GroupNonUniformSMinOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformSMinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformSMinOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformSMinOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformSMinOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformSMinOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformSMinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformSMinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformSMinOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformSMinOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformSMinOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformSMinOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformSMinOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformSMinOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformSMinOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformSMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformSMinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformSMinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformSMinOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformSMinOp::verify() {
  if (failed(GroupNonUniformSMinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformUMaxOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformUMaxOpAdaptor::GroupNonUniformUMaxOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformUMaxOpAdaptor::GroupNonUniformUMaxOpAdaptor(GroupNonUniformUMaxOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformUMaxOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformUMaxOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformUMaxOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformUMaxOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformUMaxOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformUMaxOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformUMaxOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformUMax' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformUMax' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformUMax' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformUMax' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformUMaxOp::getOperationName() {
  return "spv.GroupNonUniformUMax";
}

std::pair<unsigned, unsigned> GroupNonUniformUMaxOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformUMaxOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformUMaxOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformUMaxOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformUMaxOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformUMaxOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformUMaxOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformUMaxOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformUMaxOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformUMaxOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformUMaxOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformUMaxOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformUMaxOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformUMaxOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformUMaxOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformUMaxOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformUMaxOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformUMaxOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformUMaxOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformUMaxOp::verify() {
  if (failed(GroupNonUniformUMaxOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::GroupNonUniformUMinOp definitions
//===----------------------------------------------------------------------===//

GroupNonUniformUMinOpAdaptor::GroupNonUniformUMinOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

GroupNonUniformUMinOpAdaptor::GroupNonUniformUMinOpAdaptor(GroupNonUniformUMinOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> GroupNonUniformUMinOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange GroupNonUniformUMinOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformUMinOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformUMinOpAdaptor::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr GroupNonUniformUMinOpAdaptor::execution_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("execution_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr GroupNonUniformUMinOpAdaptor::group_operation() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("group_operation").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult GroupNonUniformUMinOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_execution_scope = odsAttrs.get("execution_scope");
  if (!tblgen_execution_scope) return emitError(loc, "'spv.GroupNonUniformUMin' op ""requires attribute 'execution_scope'");
    if (!((((tblgen_execution_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_execution_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_execution_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformUMin' op ""attribute 'execution_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_group_operation = odsAttrs.get("group_operation");
  if (!tblgen_group_operation) return emitError(loc, "'spv.GroupNonUniformUMin' op ""requires attribute 'group_operation'");
    if (!((((tblgen_group_operation.isa<::mlir::IntegerAttr>())) && ((tblgen_group_operation.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeGroupOperation(tblgen_group_operation.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.GroupNonUniformUMin' op ""attribute 'group_operation' failed to satisfy constraint: valid SPIR-V GroupOperation");
  }
  return success();
}

::llvm::StringRef GroupNonUniformUMinOp::getOperationName() {
  return "spv.GroupNonUniformUMin";
}

std::pair<unsigned, unsigned> GroupNonUniformUMinOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {false, true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 1) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range GroupNonUniformUMinOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformUMinOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::Value GroupNonUniformUMinOp::cluster_size() {
  auto operands = getODSOperands(1);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange GroupNonUniformUMinOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange GroupNonUniformUMinOp::cluster_sizeMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> GroupNonUniformUMinOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range GroupNonUniformUMinOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value GroupNonUniformUMinOp::result() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr GroupNonUniformUMinOp::execution_scopeAttr() {
  return this->getAttr("execution_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope GroupNonUniformUMinOp::execution_scope() {
  auto attr = execution_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr GroupNonUniformUMinOp::group_operationAttr() {
  return this->getAttr("group_operation").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::GroupOperation GroupNonUniformUMinOp::group_operation() {
  auto attr = group_operationAttr();
  return static_cast<::mlir::spirv::GroupOperation>(attr.getInt());
}

void GroupNonUniformUMinOp::execution_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("execution_scope", attr);
}

void GroupNonUniformUMinOp::group_operationAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("group_operation", attr);
}

void GroupNonUniformUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  odsState.addTypes(result);
}

void GroupNonUniformUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr execution_scope, ::mlir::IntegerAttr group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", execution_scope);
  odsState.addAttribute("group_operation", group_operation);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  odsState.addTypes(result);
}

void GroupNonUniformUMinOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope execution_scope, ::mlir::spirv::GroupOperation group_operation, ::mlir::Value value, /*optional*/::mlir::Value cluster_size) {
  odsState.addOperands(value);
  if (cluster_size)
    odsState.addOperands(cluster_size);
  odsState.addAttribute("execution_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(execution_scope)));
  odsState.addAttribute("group_operation", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(group_operation)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void GroupNonUniformUMinOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() >= 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult GroupNonUniformUMinOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return parseGroupNonUniformArithmeticOp(parser, result);
}

void GroupNonUniformUMinOp::print(::mlir::OpAsmPrinter &p) {
  printGroupNonUniformArithmeticOp(getOperation(), p);
}

::mlir::LogicalResult GroupNonUniformUMinOp::verify() {
  if (failed(GroupNonUniformUMinOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    if (valueGroup1.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup1.size();
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyGroupNonUniformArithmeticOp(getOperation());
}










//===----------------------------------------------------------------------===//
// spirv::IAddOp definitions
//===----------------------------------------------------------------------===//

IAddOpAdaptor::IAddOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

IAddOpAdaptor::IAddOpAdaptor(IAddOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> IAddOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange IAddOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IAddOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value IAddOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult IAddOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef IAddOp::getOperationName() {
  return "spv.IAdd";
}

std::pair<unsigned, unsigned> IAddOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range IAddOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IAddOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value IAddOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange IAddOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange IAddOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> IAddOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range IAddOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IAddOp::result() {
  return *getODSResults(0).begin();
}

void IAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void IAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void IAddOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void IAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void IAddOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult IAddOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void IAddOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult IAddOp::verify() {
  if (failed(IAddOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}











void IAddOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::IEqualOp definitions
//===----------------------------------------------------------------------===//

IEqualOpAdaptor::IEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

IEqualOpAdaptor::IEqualOpAdaptor(IEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> IEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange IEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value IEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult IEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef IEqualOp::getOperationName() {
  return "spv.IEqual";
}

std::pair<unsigned, unsigned> IEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range IEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value IEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange IEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange IEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> IEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range IEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IEqualOp::result() {
  return *getODSResults(0).begin();
}

void IEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void IEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void IEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void IEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult IEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void IEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult IEqualOp::verify() {
  if (failed(IEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void IEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::IMulOp definitions
//===----------------------------------------------------------------------===//

IMulOpAdaptor::IMulOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

IMulOpAdaptor::IMulOpAdaptor(IMulOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> IMulOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange IMulOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IMulOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value IMulOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult IMulOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef IMulOp::getOperationName() {
  return "spv.IMul";
}

std::pair<unsigned, unsigned> IMulOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range IMulOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IMulOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value IMulOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange IMulOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange IMulOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> IMulOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range IMulOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value IMulOp::result() {
  return *getODSResults(0).begin();
}

void IMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void IMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void IMulOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void IMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void IMulOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult IMulOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void IMulOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult IMulOp::verify() {
  if (failed(IMulOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}











void IMulOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::INotEqualOp definitions
//===----------------------------------------------------------------------===//

INotEqualOpAdaptor::INotEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

INotEqualOpAdaptor::INotEqualOpAdaptor(INotEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> INotEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange INotEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value INotEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value INotEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult INotEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef INotEqualOp::getOperationName() {
  return "spv.INotEqual";
}

std::pair<unsigned, unsigned> INotEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range INotEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value INotEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value INotEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange INotEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange INotEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> INotEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range INotEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value INotEqualOp::result() {
  return *getODSResults(0).begin();
}

void INotEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void INotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void INotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void INotEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult INotEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void INotEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult INotEqualOp::verify() {
  if (failed(INotEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void INotEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ISubOp definitions
//===----------------------------------------------------------------------===//

ISubOpAdaptor::ISubOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ISubOpAdaptor::ISubOpAdaptor(ISubOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ISubOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ISubOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ISubOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ISubOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult ISubOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ISubOp::getOperationName() {
  return "spv.ISub";
}

std::pair<unsigned, unsigned> ISubOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ISubOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ISubOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ISubOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange ISubOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange ISubOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ISubOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ISubOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ISubOp::result() {
  return *getODSResults(0).begin();
}

void ISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void ISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ISubOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void ISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void ISubOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult ISubOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void ISubOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult ISubOp::verify() {
  if (failed(ISubOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}











void ISubOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::LoadOp definitions
//===----------------------------------------------------------------------===//

LoadOpAdaptor::LoadOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

LoadOpAdaptor::LoadOpAdaptor(LoadOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> LoadOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange LoadOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LoadOpAdaptor::ptr() {
  return *getODSOperands(0).begin();
}

::mlir::IntegerAttr LoadOpAdaptor::memory_access() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr LoadOpAdaptor::alignment() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult LoadOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_access = odsAttrs.get("memory_access");
  if (tblgen_memory_access) {
    if (!((((tblgen_memory_access.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_access.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemoryAccess(tblgen_memory_access.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.Load' op ""attribute 'memory_access' failed to satisfy constraint: valid SPIR-V MemoryAccess");
  }
  }
  {
  auto tblgen_alignment = odsAttrs.get("alignment");
  if (tblgen_alignment) {
    if (!(((tblgen_alignment.isa<::mlir::IntegerAttr>())) && ((tblgen_alignment.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))))) return emitError(loc, "'spv.Load' op ""attribute 'alignment' failed to satisfy constraint: 32-bit signless integer attribute");
  }
  }
  return success();
}

::llvm::StringRef LoadOp::getOperationName() {
  return "spv.Load";
}

std::pair<unsigned, unsigned> LoadOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range LoadOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LoadOp::ptr() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange LoadOp::ptrMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> LoadOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range LoadOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LoadOp::value() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr LoadOp::memory_accessAttr() {
  return this->getAttr("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional<::mlir::spirv::MemoryAccess> LoadOp::memory_access() {
  auto attr = memory_accessAttr();
  return attr ? ::llvm::Optional<::mlir::spirv::MemoryAccess>(static_cast<::mlir::spirv::MemoryAccess>(attr.getInt())) : (::llvm::None);
}

::mlir::IntegerAttr LoadOp::alignmentAttr() {
  return this->getAttr("alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional< ::llvm::APInt > LoadOp::alignment() {
  auto attr = alignmentAttr();
  return attr ? ::llvm::Optional< ::llvm::APInt >(attr.getValue()) : (::llvm::None);
}

void LoadOp::memory_accessAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_access", attr);
}

void LoadOp::alignmentAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("alignment", attr);
}



void LoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type value, ::mlir::Value ptr, /*optional*/::mlir::IntegerAttr memory_access, /*optional*/::mlir::IntegerAttr alignment) {
  odsState.addOperands(ptr);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  if (alignment) {
  odsState.addAttribute("alignment", alignment);
  }
  odsState.addTypes(value);
}

void LoadOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value ptr, /*optional*/::mlir::IntegerAttr memory_access, /*optional*/::mlir::IntegerAttr alignment) {
  odsState.addOperands(ptr);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  if (alignment) {
  odsState.addAttribute("alignment", alignment);
  }
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LoadOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult LoadOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLoadOp(parser, result);
}

void LoadOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult LoadOp::verify() {
  if (failed(LoadOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::LogicalAndOp definitions
//===----------------------------------------------------------------------===//

LogicalAndOpAdaptor::LogicalAndOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

LogicalAndOpAdaptor::LogicalAndOpAdaptor(LogicalAndOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> LogicalAndOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange LogicalAndOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalAndOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalAndOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult LogicalAndOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef LogicalAndOp::getOperationName() {
  return "spv.LogicalAnd";
}

std::pair<unsigned, unsigned> LogicalAndOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range LogicalAndOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalAndOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalAndOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange LogicalAndOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange LogicalAndOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> LogicalAndOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range LogicalAndOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalAndOp::result() {
  return *getODSResults(0).begin();
}

void LogicalAndOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void LogicalAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void LogicalAndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LogicalAndOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult LogicalAndOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void LogicalAndOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult LogicalAndOp::verify() {
  if (failed(LogicalAndOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}











void LogicalAndOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::LogicalEqualOp definitions
//===----------------------------------------------------------------------===//

LogicalEqualOpAdaptor::LogicalEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

LogicalEqualOpAdaptor::LogicalEqualOpAdaptor(LogicalEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> LogicalEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange LogicalEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult LogicalEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef LogicalEqualOp::getOperationName() {
  return "spv.LogicalEqual";
}

std::pair<unsigned, unsigned> LogicalEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range LogicalEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange LogicalEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange LogicalEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> LogicalEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range LogicalEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalEqualOp::result() {
  return *getODSResults(0).begin();
}

void LogicalEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void LogicalEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void LogicalEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LogicalEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult LogicalEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void LogicalEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult LogicalEqualOp::verify() {
  if (failed(LogicalEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void LogicalEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::LogicalNotEqualOp definitions
//===----------------------------------------------------------------------===//

LogicalNotEqualOpAdaptor::LogicalNotEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

LogicalNotEqualOpAdaptor::LogicalNotEqualOpAdaptor(LogicalNotEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> LogicalNotEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange LogicalNotEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalNotEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalNotEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult LogicalNotEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef LogicalNotEqualOp::getOperationName() {
  return "spv.LogicalNotEqual";
}

std::pair<unsigned, unsigned> LogicalNotEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range LogicalNotEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalNotEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalNotEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange LogicalNotEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange LogicalNotEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> LogicalNotEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range LogicalNotEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalNotEqualOp::result() {
  return *getODSResults(0).begin();
}

void LogicalNotEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void LogicalNotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void LogicalNotEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LogicalNotEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult LogicalNotEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void LogicalNotEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult LogicalNotEqualOp::verify() {
  if (failed(LogicalNotEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void LogicalNotEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::LogicalNotOp definitions
//===----------------------------------------------------------------------===//

LogicalNotOpAdaptor::LogicalNotOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

LogicalNotOpAdaptor::LogicalNotOpAdaptor(LogicalNotOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> LogicalNotOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange LogicalNotOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalNotOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult LogicalNotOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef LogicalNotOp::getOperationName() {
  return "spv.LogicalNot";
}

std::pair<unsigned, unsigned> LogicalNotOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range LogicalNotOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalNotOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange LogicalNotOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> LogicalNotOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range LogicalNotOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalNotOp::result() {
  return *getODSResults(0).begin();
}

void LogicalNotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void LogicalNotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LogicalNotOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult LogicalNotOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalUnaryOp(parser, result);
}

void LogicalNotOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult LogicalNotOp::verify() {
  if (failed(LogicalNotOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}











void LogicalNotOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::LogicalOrOp definitions
//===----------------------------------------------------------------------===//

LogicalOrOpAdaptor::LogicalOrOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

LogicalOrOpAdaptor::LogicalOrOpAdaptor(LogicalOrOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> LogicalOrOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange LogicalOrOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalOrOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalOrOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult LogicalOrOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef LogicalOrOp::getOperationName() {
  return "spv.LogicalOr";
}

std::pair<unsigned, unsigned> LogicalOrOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range LogicalOrOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalOrOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value LogicalOrOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange LogicalOrOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange LogicalOrOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> LogicalOrOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range LogicalOrOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value LogicalOrOp::result() {
  return *getODSResults(0).begin();
}

void LogicalOrOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void LogicalOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void LogicalOrOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LogicalOrOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult LogicalOrOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void LogicalOrOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult LogicalOrOp::verify() {
  if (failed(LogicalOrOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}











void LogicalOrOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::LoopOp definitions
//===----------------------------------------------------------------------===//

LoopOpAdaptor::LoopOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

LoopOpAdaptor::LoopOpAdaptor(LoopOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> LoopOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange LoopOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr LoopOpAdaptor::loop_control() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("loop_control").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult LoopOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_loop_control = odsAttrs.get("loop_control");
  if (!tblgen_loop_control) return emitError(loc, "'spv.loop' op ""requires attribute 'loop_control'");
    if (!((((tblgen_loop_control.isa<::mlir::IntegerAttr>())) && ((tblgen_loop_control.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeLoopControl(tblgen_loop_control.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.loop' op ""attribute 'loop_control' failed to satisfy constraint: valid SPIR-V LoopControl");
  }
  return success();
}

::llvm::StringRef LoopOp::getOperationName() {
  return "spv.loop";
}

std::pair<unsigned, unsigned> LoopOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range LoopOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> LoopOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range LoopOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Region &LoopOp::body() {
  return this->getOperation()->getRegion(0);
}

::mlir::IntegerAttr LoopOp::loop_controlAttr() {
  return this->getAttr("loop_control").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::LoopControl LoopOp::loop_control() {
  auto attr = loop_controlAttr();
  return static_cast<::mlir::spirv::LoopControl>(attr.getInt());
}

void LoopOp::loop_controlAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("loop_control", attr);
}



void LoopOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr loop_control) {
  odsState.addAttribute("loop_control", loop_control);
  (void)odsState.addRegion();
}

void LoopOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr loop_control) {
  odsState.addAttribute("loop_control", loop_control);
  (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LoopOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::spirv::LoopControl loop_control) {
  odsState.addAttribute("loop_control", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(loop_control)));
  (void)odsState.addRegion();
}

void LoopOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::LoopControl loop_control) {
  odsState.addAttribute("loop_control", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(loop_control)));
  (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void LoopOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  for (unsigned i = 0; i != 1; ++i)
    (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult LoopOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLoopOp(parser, result);
}

void LoopOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult LoopOp::verify() {
  if (failed(LoopOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
{
    unsigned index = 0; (void)index;
    for (::mlir::Region &region : ::mlir::MutableArrayRef<::mlir::Region>(this->getOperation()->getRegion(0))) {
      (void)region;
      if (!((true))) {
        return emitOpError("region #") << index << " ('body') failed to verify constraint: any region";
      }
      ++index;
    }
  }
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::MatrixTimesMatrixOp definitions
//===----------------------------------------------------------------------===//

MatrixTimesMatrixOpAdaptor::MatrixTimesMatrixOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

MatrixTimesMatrixOpAdaptor::MatrixTimesMatrixOpAdaptor(MatrixTimesMatrixOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> MatrixTimesMatrixOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange MatrixTimesMatrixOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value MatrixTimesMatrixOpAdaptor::leftmatrix() {
  return *getODSOperands(0).begin();
}

::mlir::Value MatrixTimesMatrixOpAdaptor::rightmatrix() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult MatrixTimesMatrixOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef MatrixTimesMatrixOp::getOperationName() {
  return "spv.MatrixTimesMatrix";
}

std::pair<unsigned, unsigned> MatrixTimesMatrixOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range MatrixTimesMatrixOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value MatrixTimesMatrixOp::leftmatrix() {
  return *getODSOperands(0).begin();
}

::mlir::Value MatrixTimesMatrixOp::rightmatrix() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange MatrixTimesMatrixOp::leftmatrixMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange MatrixTimesMatrixOp::rightmatrixMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> MatrixTimesMatrixOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range MatrixTimesMatrixOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value MatrixTimesMatrixOp::result() {
  return *getODSResults(0).begin();
}

void MatrixTimesMatrixOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value leftmatrix, ::mlir::Value rightmatrix) {
  odsState.addOperands(leftmatrix);
  odsState.addOperands(rightmatrix);
  odsState.addTypes(result);
}

void MatrixTimesMatrixOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value leftmatrix, ::mlir::Value rightmatrix) {
  odsState.addOperands(leftmatrix);
  odsState.addOperands(rightmatrix);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void MatrixTimesMatrixOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult MatrixTimesMatrixOp::verify() {
  if (failed(MatrixTimesMatrixOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::MatrixType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::MatrixType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::MatrixType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyMatrixTimesMatrix(*this);
}









::mlir::ParseResult MatrixTimesMatrixOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type leftmatrixRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> leftmatrixTypes(leftmatrixRawTypes);
  ::mlir::Type rightmatrixRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> rightmatrixTypes(rightmatrixRawTypes);
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(leftmatrixRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(rightmatrixRawTypes[0]))
    return failure();
  if (parser.parseArrow())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  result.addTypes(resultTypes);
  if (parser.resolveOperands(allOperands, ::llvm::concat<const Type>(::llvm::ArrayRef<::mlir::Type>(leftmatrixTypes), ::llvm::ArrayRef<::mlir::Type>(rightmatrixTypes)), allOperandLoc, result.operands))
    return failure();
  return success();
}

void MatrixTimesMatrixOp::print(OpAsmPrinter &p) {
  p << "spv.MatrixTimesMatrix";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(leftmatrix().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(rightmatrix().getType());
  p << " " << "->";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}

void MatrixTimesMatrixOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::MatrixTimesScalarOp definitions
//===----------------------------------------------------------------------===//

MatrixTimesScalarOpAdaptor::MatrixTimesScalarOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

MatrixTimesScalarOpAdaptor::MatrixTimesScalarOpAdaptor(MatrixTimesScalarOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> MatrixTimesScalarOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange MatrixTimesScalarOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value MatrixTimesScalarOpAdaptor::matrix() {
  return *getODSOperands(0).begin();
}

::mlir::Value MatrixTimesScalarOpAdaptor::scalar() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult MatrixTimesScalarOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef MatrixTimesScalarOp::getOperationName() {
  return "spv.MatrixTimesScalar";
}

std::pair<unsigned, unsigned> MatrixTimesScalarOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range MatrixTimesScalarOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value MatrixTimesScalarOp::matrix() {
  return *getODSOperands(0).begin();
}

::mlir::Value MatrixTimesScalarOp::scalar() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange MatrixTimesScalarOp::matrixMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange MatrixTimesScalarOp::scalarMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> MatrixTimesScalarOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range MatrixTimesScalarOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value MatrixTimesScalarOp::result() {
  return *getODSResults(0).begin();
}

void MatrixTimesScalarOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value matrix, ::mlir::Value scalar) {
  odsState.addOperands(matrix);
  odsState.addOperands(scalar);
  odsState.addTypes(result);
}

void MatrixTimesScalarOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value matrix, ::mlir::Value scalar) {
  odsState.addOperands(matrix);
  odsState.addOperands(scalar);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void MatrixTimesScalarOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult MatrixTimesScalarOp::verify() {
  if (failed(MatrixTimesScalarOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::MatrixType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64())))) {
        return emitOpError("operand #") << index << " must be 16/32/64-bit float, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::MatrixType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyMatrixTimesScalar(*this);
}









::mlir::ParseResult MatrixTimesScalarOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type matrixRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> matrixTypes(matrixRawTypes);
  ::mlir::Type scalarRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> scalarTypes(scalarRawTypes);
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(matrixRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(scalarRawTypes[0]))
    return failure();
  if (parser.parseArrow())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  result.addTypes(resultTypes);
  if (parser.resolveOperands(allOperands, ::llvm::concat<const Type>(::llvm::ArrayRef<::mlir::Type>(matrixTypes), ::llvm::ArrayRef<::mlir::Type>(scalarTypes)), allOperandLoc, result.operands))
    return failure();
  return success();
}

void MatrixTimesScalarOp::print(OpAsmPrinter &p) {
  p << "spv.MatrixTimesScalar";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(matrix().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(scalar().getType());
  p << " " << "->";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}

void MatrixTimesScalarOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::MemoryBarrierOp definitions
//===----------------------------------------------------------------------===//

MemoryBarrierOpAdaptor::MemoryBarrierOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

MemoryBarrierOpAdaptor::MemoryBarrierOpAdaptor(MemoryBarrierOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> MemoryBarrierOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange MemoryBarrierOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr MemoryBarrierOpAdaptor::memory_scope() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_scope").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr MemoryBarrierOpAdaptor::memory_semantics() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_semantics").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult MemoryBarrierOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_scope = odsAttrs.get("memory_scope");
  if (!tblgen_memory_scope) return emitError(loc, "'spv.MemoryBarrier' op ""requires attribute 'memory_scope'");
    if (!((((tblgen_memory_scope.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_scope.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeScope(tblgen_memory_scope.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.MemoryBarrier' op ""attribute 'memory_scope' failed to satisfy constraint: valid SPIR-V Scope");
  }
  {
  auto tblgen_memory_semantics = odsAttrs.get("memory_semantics");
  if (!tblgen_memory_semantics) return emitError(loc, "'spv.MemoryBarrier' op ""requires attribute 'memory_semantics'");
    if (!((((tblgen_memory_semantics.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_semantics.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemorySemantics(tblgen_memory_semantics.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.MemoryBarrier' op ""attribute 'memory_semantics' failed to satisfy constraint: valid SPIR-V MemorySemantics");
  }
  return success();
}

::llvm::StringRef MemoryBarrierOp::getOperationName() {
  return "spv.MemoryBarrier";
}

std::pair<unsigned, unsigned> MemoryBarrierOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range MemoryBarrierOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> MemoryBarrierOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range MemoryBarrierOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr MemoryBarrierOp::memory_scopeAttr() {
  return this->getAttr("memory_scope").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::Scope MemoryBarrierOp::memory_scope() {
  auto attr = memory_scopeAttr();
  return static_cast<::mlir::spirv::Scope>(attr.getInt());
}

::mlir::IntegerAttr MemoryBarrierOp::memory_semanticsAttr() {
  return this->getAttr("memory_semantics").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemorySemantics MemoryBarrierOp::memory_semantics() {
  auto attr = memory_semanticsAttr();
  return static_cast<::mlir::spirv::MemorySemantics>(attr.getInt());
}

void MemoryBarrierOp::memory_scopeAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_scope", attr);
}

void MemoryBarrierOp::memory_semanticsAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_semantics", attr);
}

void MemoryBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr memory_semantics) {
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("memory_semantics", memory_semantics);
}

void MemoryBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr memory_scope, ::mlir::IntegerAttr memory_semantics) {
  odsState.addAttribute("memory_scope", memory_scope);
  odsState.addAttribute("memory_semantics", memory_semantics);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void MemoryBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics memory_semantics) {
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("memory_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_semantics)));
}

void MemoryBarrierOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::Scope memory_scope, ::mlir::spirv::MemorySemantics memory_semantics) {
  odsState.addAttribute("memory_scope", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_scope)));
  odsState.addAttribute("memory_semantics", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(memory_semantics)));
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void MemoryBarrierOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult MemoryBarrierOp::verify() {
  if (failed(MemoryBarrierOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  return verifyMemorySemantics(*this);
}









::mlir::ParseResult MemoryBarrierOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  {
    ::mlir::StringAttr attrVal;
    ::mlir::NamedAttrList attrStorage;
    auto loc = parser.getCurrentLocation();
    if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                              "memory_scope", attrStorage))
      return failure();

    auto attrOptional = ::mlir::spirv::symbolizeScope(attrVal.getValue());
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "memory_scope attribute specification: " << attrVal;

    result.addAttribute("memory_scope", parser.getBuilder().getI32IntegerAttr(static_cast<int32_t>(attrOptional.getValue())));
  }
  if (parser.parseComma())
    return failure();

  {
    ::mlir::StringAttr attrVal;
    ::mlir::NamedAttrList attrStorage;
    auto loc = parser.getCurrentLocation();
    if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                              "memory_semantics", attrStorage))
      return failure();

    auto attrOptional = ::mlir::spirv::symbolizeMemorySemantics(attrVal.getValue());
    if (!attrOptional)
      return parser.emitError(loc, "invalid ")
             << "memory_semantics attribute specification: " << attrVal;

    result.addAttribute("memory_semantics", parser.getBuilder().getI32IntegerAttr(static_cast<int32_t>(attrOptional.getValue())));
  }
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  return success();
}

void MemoryBarrierOp::print(OpAsmPrinter &p) {
  p << "spv.MemoryBarrier";
  p << " ";
  p << "\"" << stringifyScope(memory_scope()) << "\"";
  p << ",";
  p << " ";
  p << "\"" << stringifyMemorySemantics(memory_semantics()) << "\"";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"memory_scope", "memory_semantics"});
}


//===----------------------------------------------------------------------===//
// spirv::MergeOp definitions
//===----------------------------------------------------------------------===//

MergeOpAdaptor::MergeOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

MergeOpAdaptor::MergeOpAdaptor(MergeOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> MergeOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange MergeOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::LogicalResult MergeOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef MergeOp::getOperationName() {
  return "spv._merge";
}

std::pair<unsigned, unsigned> MergeOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range MergeOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> MergeOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range MergeOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

void MergeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) {

}

void MergeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes) {
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void MergeOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult MergeOp::verify() {
  if (failed(MergeOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  return ::verify(*this);
}









::mlir::ParseResult MergeOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  return success();
}

void MergeOp::print(OpAsmPrinter &p) {
  p << "spv._merge";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
}

void MergeOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ModuleEndOp definitions
//===----------------------------------------------------------------------===//

ModuleEndOpAdaptor::ModuleEndOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ModuleEndOpAdaptor::ModuleEndOpAdaptor(ModuleEndOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ModuleEndOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ModuleEndOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::LogicalResult ModuleEndOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ModuleEndOp::getOperationName() {
  return "spv._module_end";
}

std::pair<unsigned, unsigned> ModuleEndOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ModuleEndOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> ModuleEndOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ModuleEndOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

void ModuleEndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) {

}

void ModuleEndOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes) {
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ModuleEndOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult ModuleEndOp::verify() {
  if (failed(ModuleEndOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isDirectInModuleLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a module-like op's block");
  return success();
}









::mlir::ParseResult ModuleEndOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  return success();
}

void ModuleEndOp::print(OpAsmPrinter &p) {
  p << "spv._module_end";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
}


//===----------------------------------------------------------------------===//
// spirv::ModuleOp definitions
//===----------------------------------------------------------------------===//

ModuleOpAdaptor::ModuleOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ModuleOpAdaptor::ModuleOpAdaptor(ModuleOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ModuleOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ModuleOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr ModuleOpAdaptor::addressing_model() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("addressing_model").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr ModuleOpAdaptor::memory_model() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_model").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::spirv::VerCapExtAttr ModuleOpAdaptor::vce_triple() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::spirv::VerCapExtAttr attr = odsAttrs.get("vce_triple").dyn_cast_or_null<::mlir::spirv::VerCapExtAttr>();
  return attr;
}

::mlir::LogicalResult ModuleOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_addressing_model = odsAttrs.get("addressing_model");
  if (!tblgen_addressing_model) return emitError(loc, "'spv.module' op ""requires attribute 'addressing_model'");
    if (!((((tblgen_addressing_model.isa<::mlir::IntegerAttr>())) && ((tblgen_addressing_model.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeAddressingModel(tblgen_addressing_model.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.module' op ""attribute 'addressing_model' failed to satisfy constraint: valid SPIR-V AddressingModel");
  }
  {
  auto tblgen_memory_model = odsAttrs.get("memory_model");
  if (!tblgen_memory_model) return emitError(loc, "'spv.module' op ""requires attribute 'memory_model'");
    if (!((((tblgen_memory_model.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_model.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemoryModel(tblgen_memory_model.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.module' op ""attribute 'memory_model' failed to satisfy constraint: valid SPIR-V MemoryModel");
  }
  {
  auto tblgen_vce_triple = odsAttrs.get("vce_triple");
  if (tblgen_vce_triple) {
    if (!((tblgen_vce_triple.isa<::mlir::spirv::VerCapExtAttr>()))) return emitError(loc, "'spv.module' op ""attribute 'vce_triple' failed to satisfy constraint: version-capability-extension attribute");
  }
  }
  return success();
}

::llvm::StringRef ModuleOp::getOperationName() {
  return "spv.module";
}

std::pair<unsigned, unsigned> ModuleOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ModuleOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> ModuleOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ModuleOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Region &ModuleOp::body() {
  return this->getOperation()->getRegion(0);
}

::mlir::IntegerAttr ModuleOp::addressing_modelAttr() {
  return this->getAttr("addressing_model").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::AddressingModel ModuleOp::addressing_model() {
  auto attr = addressing_modelAttr();
  return static_cast<::mlir::spirv::AddressingModel>(attr.getInt());
}

::mlir::IntegerAttr ModuleOp::memory_modelAttr() {
  return this->getAttr("memory_model").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::MemoryModel ModuleOp::memory_model() {
  auto attr = memory_modelAttr();
  return static_cast<::mlir::spirv::MemoryModel>(attr.getInt());
}

::mlir::spirv::VerCapExtAttr ModuleOp::vce_tripleAttr() {
  return this->getAttr("vce_triple").dyn_cast_or_null<::mlir::spirv::VerCapExtAttr>();
}

::llvm::Optional<::mlir::spirv::VerCapExtAttr> ModuleOp::vce_triple() {
  auto attr = vce_tripleAttr();
  return attr ? ::llvm::Optional<::mlir::spirv::VerCapExtAttr>(attr) : (::llvm::None);
}

void ModuleOp::addressing_modelAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("addressing_model", attr);
}

void ModuleOp::memory_modelAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_model", attr);
}

void ModuleOp::vce_tripleAttr(::mlir::spirv::VerCapExtAttr attr) {
  this->getOperation()->setAttr("vce_triple", attr);
}





::mlir::ParseResult ModuleOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseModuleOp(parser, result);
}

void ModuleOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult ModuleOp::verify() {
  if (failed(ModuleOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
{
    unsigned index = 0; (void)index;
    for (::mlir::Region &region : ::mlir::MutableArrayRef<::mlir::Region>(this->getOperation()->getRegion(0))) {
      (void)region;
      if (!((::llvm::hasNItems(region, 1)))) {
        return emitOpError("region #") << index << " ('body') failed to verify constraint: region with 1 blocks";
      }
      ++index;
    }
  }
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::NotOp definitions
//===----------------------------------------------------------------------===//

NotOpAdaptor::NotOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

NotOpAdaptor::NotOpAdaptor(NotOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> NotOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange NotOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value NotOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult NotOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef NotOp::getOperationName() {
  return "spv.Not";
}

std::pair<unsigned, unsigned> NotOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range NotOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value NotOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange NotOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> NotOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range NotOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value NotOp::result() {
  return *getODSResults(0).begin();
}

void NotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void NotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void NotOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void NotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes({operand.getType()});

}

void NotOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult NotOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseUnaryOp(parser, result);
}

void NotOp::print(::mlir::OpAsmPrinter &p) {
  return ::printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult NotOp::verify() {
  if (failed(NotOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void NotOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ReferenceOfOp definitions
//===----------------------------------------------------------------------===//

ReferenceOfOpAdaptor::ReferenceOfOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ReferenceOfOpAdaptor::ReferenceOfOpAdaptor(ReferenceOfOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ReferenceOfOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ReferenceOfOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::FlatSymbolRefAttr ReferenceOfOpAdaptor::spec_const() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::FlatSymbolRefAttr attr = odsAttrs.get("spec_const").cast<::mlir::FlatSymbolRefAttr>();
  return attr;
}

::mlir::LogicalResult ReferenceOfOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_spec_const = odsAttrs.get("spec_const");
  if (!tblgen_spec_const) return emitError(loc, "'spv._reference_of' op ""requires attribute 'spec_const'");
    if (!((tblgen_spec_const.isa<::mlir::FlatSymbolRefAttr>()))) return emitError(loc, "'spv._reference_of' op ""attribute 'spec_const' failed to satisfy constraint: flat symbol reference attribute");
  }
  return success();
}

::llvm::StringRef ReferenceOfOp::getOperationName() {
  return "spv._reference_of";
}

std::pair<unsigned, unsigned> ReferenceOfOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ReferenceOfOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> ReferenceOfOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ReferenceOfOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ReferenceOfOp::reference() {
  return *getODSResults(0).begin();
}

::mlir::FlatSymbolRefAttr ReferenceOfOp::spec_constAttr() {
  return this->getAttr("spec_const").cast<::mlir::FlatSymbolRefAttr>();
}

::llvm::StringRef ReferenceOfOp::spec_const() {
  auto attr = spec_constAttr();
  return attr.getValue();
}

void ReferenceOfOp::spec_constAttr(::mlir::FlatSymbolRefAttr attr) {
  this->getOperation()->setAttr("spec_const", attr);
}

void ReferenceOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type reference, ::mlir::FlatSymbolRefAttr spec_const) {
  odsState.addAttribute("spec_const", spec_const);
  odsState.addTypes(reference);
}

void ReferenceOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::FlatSymbolRefAttr spec_const) {
  odsState.addAttribute("spec_const", spec_const);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ReferenceOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type reference, ::llvm::StringRef spec_const) {
  odsState.addAttribute("spec_const", odsBuilder.getSymbolRefAttr(spec_const));
  odsState.addTypes(reference);
}

void ReferenceOfOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::llvm::StringRef spec_const) {
  odsState.addAttribute("spec_const", odsBuilder.getSymbolRefAttr(spec_const));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ReferenceOfOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult ReferenceOfOp::verify() {
  if (failed(ReferenceOfOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}









::mlir::ParseResult ReferenceOfOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type referenceRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> referenceTypes(referenceRawTypes);

  ::mlir::FlatSymbolRefAttr spec_constAttr;
  if (parser.parseAttribute(spec_constAttr, parser.getBuilder().getType<::mlir::NoneType>(), "spec_const", result.attributes))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(referenceRawTypes[0]))
    return failure();
  result.addTypes(referenceTypes);
  return success();
}

void ReferenceOfOp::print(OpAsmPrinter &p) {
  p << "spv._reference_of";
  p << " ";
  p.printAttributeWithoutType(spec_constAttr());
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{"spec_const"});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(reference().getType());
}

void ReferenceOfOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ReturnOp definitions
//===----------------------------------------------------------------------===//

ReturnOpAdaptor::ReturnOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ReturnOpAdaptor::ReturnOpAdaptor(ReturnOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ReturnOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ReturnOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::LogicalResult ReturnOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ReturnOp::getOperationName() {
  return "spv.Return";
}

std::pair<unsigned, unsigned> ReturnOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ReturnOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> ReturnOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ReturnOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

void ReturnOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) {

}

void ReturnOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes) {
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ReturnOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult ReturnOp::verify() {
  if (failed(ReturnOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
  return ::verify(*this);
}









::mlir::ParseResult ReturnOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  return success();
}

void ReturnOp::print(OpAsmPrinter &p) {
  p << "spv.Return";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
}

void ReturnOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ReturnValueOp definitions
//===----------------------------------------------------------------------===//

ReturnValueOpAdaptor::ReturnValueOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ReturnValueOpAdaptor::ReturnValueOpAdaptor(ReturnValueOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ReturnValueOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ReturnValueOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ReturnValueOpAdaptor::value() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult ReturnValueOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ReturnValueOp::getOperationName() {
  return "spv.ReturnValue";
}

std::pair<unsigned, unsigned> ReturnValueOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ReturnValueOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ReturnValueOp::value() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange ReturnValueOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ReturnValueOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ReturnValueOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

void ReturnValueOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value value) {
  odsState.addOperands(value);
}

void ReturnValueOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value value) {
  odsState.addOperands(value);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ReturnValueOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult ReturnValueOp::verify() {
  if (failed(ReturnValueOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
  return ::verify(*this);
}









::mlir::ParseResult ReturnValueOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::OpAsmParser::OperandType valueRawOperands[1];
  ::llvm::ArrayRef<::mlir::OpAsmParser::OperandType> valueOperands(valueRawOperands);  ::llvm::SMLoc valueOperandsLoc = parser.getCurrentLocation();
  (void)valueOperandsLoc;
  ::mlir::Type valueRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> valueTypes(valueRawTypes);

  if (parser.parseOperand(valueRawOperands[0]))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(valueRawTypes[0]))
    return failure();
  if (parser.resolveOperands(valueOperands, valueTypes, valueOperandsLoc, result.operands))
    return failure();
  return success();
}

void ReturnValueOp::print(OpAsmPrinter &p) {
  p << "spv.ReturnValue";
  p << " ";
  p << value();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(value().getType());
}

void ReturnValueOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SConvertOp definitions
//===----------------------------------------------------------------------===//

SConvertOpAdaptor::SConvertOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SConvertOpAdaptor::SConvertOpAdaptor(SConvertOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SConvertOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SConvertOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SConvertOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult SConvertOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SConvertOp::getOperationName() {
  return "spv.SConvert";
}

std::pair<unsigned, unsigned> SConvertOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SConvertOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SConvertOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange SConvertOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SConvertOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SConvertOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SConvertOp::result() {
  return *getODSResults(0).begin();
}

void SConvertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void SConvertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SConvertOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult SConvertOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void SConvertOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult SConvertOp::verify() {
  if (failed(SConvertOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyCastOp(this->getOperation(), false);
}









void SConvertOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SDivOp definitions
//===----------------------------------------------------------------------===//

SDivOpAdaptor::SDivOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SDivOpAdaptor::SDivOpAdaptor(SDivOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SDivOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SDivOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SDivOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SDivOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult SDivOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SDivOp::getOperationName() {
  return "spv.SDiv";
}

std::pair<unsigned, unsigned> SDivOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SDivOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SDivOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SDivOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange SDivOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SDivOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SDivOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SDivOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SDivOp::result() {
  return *getODSResults(0).begin();
}

void SDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void SDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SDivOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void SDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void SDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult SDivOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void SDivOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult SDivOp::verify() {
  if (failed(SDivOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SDivOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SGreaterThanEqualOp definitions
//===----------------------------------------------------------------------===//

SGreaterThanEqualOpAdaptor::SGreaterThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SGreaterThanEqualOpAdaptor::SGreaterThanEqualOpAdaptor(SGreaterThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SGreaterThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SGreaterThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SGreaterThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SGreaterThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult SGreaterThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SGreaterThanEqualOp::getOperationName() {
  return "spv.SGreaterThanEqual";
}

std::pair<unsigned, unsigned> SGreaterThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SGreaterThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SGreaterThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SGreaterThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange SGreaterThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SGreaterThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SGreaterThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SGreaterThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SGreaterThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void SGreaterThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void SGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void SGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SGreaterThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult SGreaterThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void SGreaterThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult SGreaterThanEqualOp::verify() {
  if (failed(SGreaterThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SGreaterThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SGreaterThanOp definitions
//===----------------------------------------------------------------------===//

SGreaterThanOpAdaptor::SGreaterThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SGreaterThanOpAdaptor::SGreaterThanOpAdaptor(SGreaterThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SGreaterThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SGreaterThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SGreaterThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SGreaterThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult SGreaterThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SGreaterThanOp::getOperationName() {
  return "spv.SGreaterThan";
}

std::pair<unsigned, unsigned> SGreaterThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SGreaterThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SGreaterThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SGreaterThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange SGreaterThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SGreaterThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SGreaterThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SGreaterThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SGreaterThanOp::result() {
  return *getODSResults(0).begin();
}

void SGreaterThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void SGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void SGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SGreaterThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult SGreaterThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void SGreaterThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult SGreaterThanOp::verify() {
  if (failed(SGreaterThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SGreaterThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SLessThanEqualOp definitions
//===----------------------------------------------------------------------===//

SLessThanEqualOpAdaptor::SLessThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SLessThanEqualOpAdaptor::SLessThanEqualOpAdaptor(SLessThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SLessThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SLessThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SLessThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SLessThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult SLessThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SLessThanEqualOp::getOperationName() {
  return "spv.SLessThanEqual";
}

std::pair<unsigned, unsigned> SLessThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SLessThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SLessThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SLessThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange SLessThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SLessThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SLessThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SLessThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SLessThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void SLessThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void SLessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void SLessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SLessThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult SLessThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void SLessThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult SLessThanEqualOp::verify() {
  if (failed(SLessThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SLessThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SLessThanOp definitions
//===----------------------------------------------------------------------===//

SLessThanOpAdaptor::SLessThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SLessThanOpAdaptor::SLessThanOpAdaptor(SLessThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SLessThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SLessThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SLessThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SLessThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult SLessThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SLessThanOp::getOperationName() {
  return "spv.SLessThan";
}

std::pair<unsigned, unsigned> SLessThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SLessThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SLessThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SLessThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange SLessThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SLessThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SLessThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SLessThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SLessThanOp::result() {
  return *getODSResults(0).begin();
}

void SLessThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void SLessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void SLessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SLessThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult SLessThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void SLessThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult SLessThanOp::verify() {
  if (failed(SLessThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SLessThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SModOp definitions
//===----------------------------------------------------------------------===//

SModOpAdaptor::SModOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SModOpAdaptor::SModOpAdaptor(SModOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SModOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SModOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SModOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SModOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult SModOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SModOp::getOperationName() {
  return "spv.SMod";
}

std::pair<unsigned, unsigned> SModOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SModOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SModOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SModOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange SModOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SModOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SModOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SModOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SModOp::result() {
  return *getODSResults(0).begin();
}

void SModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void SModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SModOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void SModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void SModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult SModOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void SModOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult SModOp::verify() {
  if (failed(SModOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SModOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SNegateOp definitions
//===----------------------------------------------------------------------===//

SNegateOpAdaptor::SNegateOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SNegateOpAdaptor::SNegateOpAdaptor(SNegateOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SNegateOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SNegateOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SNegateOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult SNegateOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SNegateOp::getOperationName() {
  return "spv.SNegate";
}

std::pair<unsigned, unsigned> SNegateOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SNegateOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SNegateOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange SNegateOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SNegateOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SNegateOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SNegateOp::result() {
  return *getODSResults(0).begin();
}

void SNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void SNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SNegateOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void SNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes({operand.getType()});

}

void SNegateOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult SNegateOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseUnaryOp(parser, result);
}

void SNegateOp::print(::mlir::OpAsmPrinter &p) {
  return ::printUnaryOp(getOperation(), p);
}

::mlir::LogicalResult SNegateOp::verify() {
  if (failed(SNegateOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SNegateOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SRemOp definitions
//===----------------------------------------------------------------------===//

SRemOpAdaptor::SRemOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SRemOpAdaptor::SRemOpAdaptor(SRemOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SRemOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SRemOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SRemOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SRemOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult SRemOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SRemOp::getOperationName() {
  return "spv.SRem";
}

std::pair<unsigned, unsigned> SRemOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SRemOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SRemOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value SRemOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange SRemOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SRemOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SRemOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SRemOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SRemOp::result() {
  return *getODSResults(0).begin();
}

void SRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void SRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SRemOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void SRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void SRemOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult SRemOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void SRemOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult SRemOp::verify() {
  if (failed(SRemOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void SRemOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SelectOp definitions
//===----------------------------------------------------------------------===//

SelectOpAdaptor::SelectOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SelectOpAdaptor::SelectOpAdaptor(SelectOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SelectOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SelectOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SelectOpAdaptor::condition() {
  return *getODSOperands(0).begin();
}

::mlir::Value SelectOpAdaptor::true_value() {
  return *getODSOperands(1).begin();
}

::mlir::Value SelectOpAdaptor::false_value() {
  return *getODSOperands(2).begin();
}

::mlir::LogicalResult SelectOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SelectOp::getOperationName() {
  return "spv.Select";
}

std::pair<unsigned, unsigned> SelectOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SelectOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SelectOp::condition() {
  return *getODSOperands(0).begin();
}

::mlir::Value SelectOp::true_value() {
  return *getODSOperands(1).begin();
}

::mlir::Value SelectOp::false_value() {
  return *getODSOperands(2).begin();
}

::mlir::MutableOperandRange SelectOp::conditionMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SelectOp::true_valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange SelectOp::false_valueMutable() {
  auto range = getODSOperandIndexAndLength(2);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SelectOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SelectOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SelectOp::result() {
  return *getODSResults(0).begin();
}



void SelectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value condition, ::mlir::Value true_value, ::mlir::Value false_value) {
  odsState.addOperands(condition);
  odsState.addOperands(true_value);
  odsState.addOperands(false_value);
  odsState.addTypes(result);
}

void SelectOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value condition, ::mlir::Value true_value, ::mlir::Value false_value) {
  odsState.addOperands(condition);
  odsState.addOperands(true_value);
  odsState.addOperands(false_value);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SelectOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 3u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult SelectOp::verify() {
  if (failed(SelectOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64())))) || ((v.getType().isSignlessInteger(1)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or 16/32/64-bit float or bool or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup2 = getODSOperands(2);
    for (::mlir::Value v : valueGroup2) {
      (void)v;
      if (!((((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64())))) || ((v.getType().isSignlessInteger(1)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or 16/32/64-bit float or bool or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64())))) || ((v.getType().isSignlessInteger(1)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or 16/32/64-bit float or bool or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  if (!((::llvm::is_splat(::llvm::makeArrayRef({(*this->getODSOperands(1).begin()).getType(), (*this->getODSOperands(2).begin()).getType(), (*this->getODSResults(0).begin()).getType()})))))
    return emitOpError("failed to verify that all of {true_value, false_value, result} have same type");
  return ::verify(*this);
}









::mlir::ParseResult SelectOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type conditionRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> conditionTypes(conditionRawTypes);
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(conditionRawTypes[0]))
    return failure();
  if (parser.parseComma())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  result.addTypes(resultTypes);
  if (parser.resolveOperands(allOperands, ::llvm::concat<const Type>(::llvm::ArrayRef<::mlir::Type>(conditionTypes), ::llvm::ArrayRef<::mlir::Type>(resultTypes), ::llvm::ArrayRef<::mlir::Type>(resultTypes)), allOperandLoc, result.operands))
    return failure();
  return success();
}

void SelectOp::print(OpAsmPrinter &p) {
  p << "spv.Select";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(condition().getType());
  p << ",";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}

void SelectOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SelectionOp definitions
//===----------------------------------------------------------------------===//

SelectionOpAdaptor::SelectionOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SelectionOpAdaptor::SelectionOpAdaptor(SelectionOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SelectionOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SelectionOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr SelectionOpAdaptor::selection_control() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("selection_control").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult SelectionOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_selection_control = odsAttrs.get("selection_control");
  if (!tblgen_selection_control) return emitError(loc, "'spv.selection' op ""requires attribute 'selection_control'");
    if (!((((tblgen_selection_control.isa<::mlir::IntegerAttr>())) && ((tblgen_selection_control.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeSelectionControl(tblgen_selection_control.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.selection' op ""attribute 'selection_control' failed to satisfy constraint: valid SPIR-V SelectionControl");
  }
  return success();
}

::llvm::StringRef SelectionOp::getOperationName() {
  return "spv.selection";
}

std::pair<unsigned, unsigned> SelectionOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SelectionOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> SelectionOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SelectionOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Region &SelectionOp::body() {
  return this->getOperation()->getRegion(0);
}

::mlir::IntegerAttr SelectionOp::selection_controlAttr() {
  return this->getAttr("selection_control").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::SelectionControl SelectionOp::selection_control() {
  auto attr = selection_controlAttr();
  return static_cast<::mlir::spirv::SelectionControl>(attr.getInt());
}

void SelectionOp::selection_controlAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("selection_control", attr);
}

void SelectionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::IntegerAttr selection_control) {
  odsState.addAttribute("selection_control", selection_control);
  (void)odsState.addRegion();
}

void SelectionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr selection_control) {
  odsState.addAttribute("selection_control", selection_control);
  (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SelectionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::spirv::SelectionControl selection_control) {
  odsState.addAttribute("selection_control", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(selection_control)));
  (void)odsState.addRegion();
}

void SelectionOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::SelectionControl selection_control) {
  odsState.addAttribute("selection_control", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(selection_control)));
  (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SelectionOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  for (unsigned i = 0; i != 1; ++i)
    (void)odsState.addRegion();
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult SelectionOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseSelectionOp(parser, result);
}

void SelectionOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult SelectionOp::verify() {
  if (failed(SelectionOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
{
    unsigned index = 0; (void)index;
    for (::mlir::Region &region : ::mlir::MutableArrayRef<::mlir::Region>(this->getOperation()->getRegion(0))) {
      (void)region;
      if (!((true))) {
        return emitOpError("region #") << index << " ('body') failed to verify constraint: any region";
      }
      ++index;
    }
  }
  return ::verify(*this);
}












//===----------------------------------------------------------------------===//
// spirv::ShiftLeftLogicalOp definitions
//===----------------------------------------------------------------------===//

ShiftLeftLogicalOpAdaptor::ShiftLeftLogicalOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ShiftLeftLogicalOpAdaptor::ShiftLeftLogicalOpAdaptor(ShiftLeftLogicalOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ShiftLeftLogicalOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ShiftLeftLogicalOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftLeftLogicalOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ShiftLeftLogicalOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult ShiftLeftLogicalOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ShiftLeftLogicalOp::getOperationName() {
  return "spv.ShiftLeftLogical";
}

std::pair<unsigned, unsigned> ShiftLeftLogicalOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ShiftLeftLogicalOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftLeftLogicalOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ShiftLeftLogicalOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange ShiftLeftLogicalOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange ShiftLeftLogicalOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ShiftLeftLogicalOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ShiftLeftLogicalOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftLeftLogicalOp::result() {
  return *getODSResults(0).begin();
}

void ShiftLeftLogicalOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void ShiftLeftLogicalOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ShiftLeftLogicalOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ShiftLeftLogicalOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseShiftOp(parser, result);
}

void ShiftLeftLogicalOp::print(::mlir::OpAsmPrinter &p) {
  ::printShiftOp(this->getOperation(), p);
}

::mlir::LogicalResult ShiftLeftLogicalOp::verify() {
  if (failed(ShiftLeftLogicalOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyShiftOp(this->getOperation());
}









void ShiftLeftLogicalOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ShiftRightArithmeticOp definitions
//===----------------------------------------------------------------------===//

ShiftRightArithmeticOpAdaptor::ShiftRightArithmeticOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ShiftRightArithmeticOpAdaptor::ShiftRightArithmeticOpAdaptor(ShiftRightArithmeticOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ShiftRightArithmeticOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ShiftRightArithmeticOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftRightArithmeticOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ShiftRightArithmeticOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult ShiftRightArithmeticOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ShiftRightArithmeticOp::getOperationName() {
  return "spv.ShiftRightArithmetic";
}

std::pair<unsigned, unsigned> ShiftRightArithmeticOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ShiftRightArithmeticOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftRightArithmeticOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ShiftRightArithmeticOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange ShiftRightArithmeticOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange ShiftRightArithmeticOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ShiftRightArithmeticOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ShiftRightArithmeticOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftRightArithmeticOp::result() {
  return *getODSResults(0).begin();
}

void ShiftRightArithmeticOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void ShiftRightArithmeticOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ShiftRightArithmeticOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ShiftRightArithmeticOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseShiftOp(parser, result);
}

void ShiftRightArithmeticOp::print(::mlir::OpAsmPrinter &p) {
  ::printShiftOp(this->getOperation(), p);
}

::mlir::LogicalResult ShiftRightArithmeticOp::verify() {
  if (failed(ShiftRightArithmeticOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyShiftOp(this->getOperation());
}









void ShiftRightArithmeticOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ShiftRightLogicalOp definitions
//===----------------------------------------------------------------------===//

ShiftRightLogicalOpAdaptor::ShiftRightLogicalOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ShiftRightLogicalOpAdaptor::ShiftRightLogicalOpAdaptor(ShiftRightLogicalOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ShiftRightLogicalOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ShiftRightLogicalOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftRightLogicalOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ShiftRightLogicalOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult ShiftRightLogicalOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ShiftRightLogicalOp::getOperationName() {
  return "spv.ShiftRightLogical";
}

std::pair<unsigned, unsigned> ShiftRightLogicalOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ShiftRightLogicalOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftRightLogicalOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ShiftRightLogicalOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange ShiftRightLogicalOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange ShiftRightLogicalOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ShiftRightLogicalOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ShiftRightLogicalOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ShiftRightLogicalOp::result() {
  return *getODSResults(0).begin();
}

void ShiftRightLogicalOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void ShiftRightLogicalOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ShiftRightLogicalOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ShiftRightLogicalOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseShiftOp(parser, result);
}

void ShiftRightLogicalOp::print(::mlir::OpAsmPrinter &p) {
  ::printShiftOp(this->getOperation(), p);
}

::mlir::LogicalResult ShiftRightLogicalOp::verify() {
  if (failed(ShiftRightLogicalOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verifyShiftOp(this->getOperation());
}









void ShiftRightLogicalOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::SpecConstantOp definitions
//===----------------------------------------------------------------------===//

SpecConstantOpAdaptor::SpecConstantOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SpecConstantOpAdaptor::SpecConstantOpAdaptor(SpecConstantOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SpecConstantOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SpecConstantOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::StringAttr SpecConstantOpAdaptor::sym_name() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::StringAttr attr = odsAttrs.get("sym_name").cast<::mlir::StringAttr>();
  return attr;
}

::mlir::Attribute SpecConstantOpAdaptor::default_value() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::Attribute attr = odsAttrs.get("default_value").cast<::mlir::Attribute>();
  return attr;
}

::mlir::LogicalResult SpecConstantOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_sym_name = odsAttrs.get("sym_name");
  if (!tblgen_sym_name) return emitError(loc, "'spv.specConstant' op ""requires attribute 'sym_name'");
    if (!((tblgen_sym_name.isa<::mlir::StringAttr>()))) return emitError(loc, "'spv.specConstant' op ""attribute 'sym_name' failed to satisfy constraint: string attribute");
  }
  {
  auto tblgen_default_value = odsAttrs.get("default_value");
  if (!tblgen_default_value) return emitError(loc, "'spv.specConstant' op ""requires attribute 'default_value'");
    if (!((true))) return emitError(loc, "'spv.specConstant' op ""attribute 'default_value' failed to satisfy constraint: any attribute");
  }
  return success();
}

::llvm::StringRef SpecConstantOp::getOperationName() {
  return "spv.specConstant";
}

std::pair<unsigned, unsigned> SpecConstantOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SpecConstantOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> SpecConstantOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SpecConstantOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::StringAttr SpecConstantOp::sym_nameAttr() {
  return this->getAttr("sym_name").cast<::mlir::StringAttr>();
}

::llvm::StringRef SpecConstantOp::sym_name() {
  auto attr = sym_nameAttr();
  return attr.getValue();
}

::mlir::Attribute SpecConstantOp::default_valueAttr() {
  return this->getAttr("default_value").cast<::mlir::Attribute>();
}

::mlir::Attribute SpecConstantOp::default_value() {
  auto attr = default_valueAttr();
  return attr;
}

void SpecConstantOp::sym_nameAttr(::mlir::StringAttr attr) {
  this->getOperation()->setAttr("sym_name", attr);
}

void SpecConstantOp::default_valueAttr(::mlir::Attribute attr) {
  this->getOperation()->setAttr("default_value", attr);
}

void SpecConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::StringAttr sym_name, ::mlir::Attribute default_value) {
  odsState.addAttribute("sym_name", sym_name);
  odsState.addAttribute("default_value", default_value);
}

void SpecConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::StringAttr sym_name, ::mlir::Attribute default_value) {
  odsState.addAttribute("sym_name", sym_name);
  odsState.addAttribute("default_value", default_value);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SpecConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::StringRef sym_name, ::mlir::Attribute default_value) {
  odsState.addAttribute("sym_name", odsBuilder.getStringAttr(sym_name));
  odsState.addAttribute("default_value", default_value);
}

void SpecConstantOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::llvm::StringRef sym_name, ::mlir::Attribute default_value) {
  odsState.addAttribute("sym_name", odsBuilder.getStringAttr(sym_name));
  odsState.addAttribute("default_value", default_value);
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SpecConstantOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult SpecConstantOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseSpecConstantOp(parser, result);
}

void SpecConstantOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult SpecConstantOp::verify() {
  if (failed(SpecConstantOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isDirectInModuleLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a module-like op's block");
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::StoreOp definitions
//===----------------------------------------------------------------------===//

StoreOpAdaptor::StoreOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

StoreOpAdaptor::StoreOpAdaptor(StoreOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> StoreOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange StoreOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value StoreOpAdaptor::ptr() {
  return *getODSOperands(0).begin();
}

::mlir::Value StoreOpAdaptor::value() {
  return *getODSOperands(1).begin();
}

::mlir::IntegerAttr StoreOpAdaptor::memory_access() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::IntegerAttr StoreOpAdaptor::alignment() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult StoreOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_memory_access = odsAttrs.get("memory_access");
  if (tblgen_memory_access) {
    if (!((((tblgen_memory_access.isa<::mlir::IntegerAttr>())) && ((tblgen_memory_access.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeMemoryAccess(tblgen_memory_access.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.Store' op ""attribute 'memory_access' failed to satisfy constraint: valid SPIR-V MemoryAccess");
  }
  }
  {
  auto tblgen_alignment = odsAttrs.get("alignment");
  if (tblgen_alignment) {
    if (!(((tblgen_alignment.isa<::mlir::IntegerAttr>())) && ((tblgen_alignment.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32))))) return emitError(loc, "'spv.Store' op ""attribute 'alignment' failed to satisfy constraint: 32-bit signless integer attribute");
  }
  }
  return success();
}

::llvm::StringRef StoreOp::getOperationName() {
  return "spv.Store";
}

std::pair<unsigned, unsigned> StoreOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range StoreOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value StoreOp::ptr() {
  return *getODSOperands(0).begin();
}

::mlir::Value StoreOp::value() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange StoreOp::ptrMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange StoreOp::valueMutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> StoreOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range StoreOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::IntegerAttr StoreOp::memory_accessAttr() {
  return this->getAttr("memory_access").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional<::mlir::spirv::MemoryAccess> StoreOp::memory_access() {
  auto attr = memory_accessAttr();
  return attr ? ::llvm::Optional<::mlir::spirv::MemoryAccess>(static_cast<::mlir::spirv::MemoryAccess>(attr.getInt())) : (::llvm::None);
}

::mlir::IntegerAttr StoreOp::alignmentAttr() {
  return this->getAttr("alignment").dyn_cast_or_null<::mlir::IntegerAttr>();
}

::llvm::Optional< ::llvm::APInt > StoreOp::alignment() {
  auto attr = alignmentAttr();
  return attr ? ::llvm::Optional< ::llvm::APInt >(attr.getValue()) : (::llvm::None);
}

void StoreOp::memory_accessAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("memory_access", attr);
}

void StoreOp::alignmentAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("alignment", attr);
}

void StoreOp::build(OpBuilder &builder, OperationState &state, Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs ) {
      state.addOperands(ptr);
      state.addOperands(value);
      state.addAttributes(namedAttrs);
    
}

void StoreOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value ptr, ::mlir::Value value, /*optional*/::mlir::IntegerAttr memory_access, /*optional*/::mlir::IntegerAttr alignment) {
  odsState.addOperands(ptr);
  odsState.addOperands(value);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  if (alignment) {
  odsState.addAttribute("alignment", alignment);
  }
}

void StoreOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value ptr, ::mlir::Value value, /*optional*/::mlir::IntegerAttr memory_access, /*optional*/::mlir::IntegerAttr alignment) {
  odsState.addOperands(ptr);
  odsState.addOperands(value);
  if (memory_access) {
  odsState.addAttribute("memory_access", memory_access);
  }
  if (alignment) {
  odsState.addAttribute("alignment", alignment);
  }
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void StoreOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult StoreOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseStoreOp(parser, result);
}

void StoreOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult StoreOp::verify() {
  if (failed(StoreOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("operand #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
  }
  return ::verify(*this);
}










//===----------------------------------------------------------------------===//
// spirv::SubgroupBallotKHROp definitions
//===----------------------------------------------------------------------===//

SubgroupBallotKHROpAdaptor::SubgroupBallotKHROpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

SubgroupBallotKHROpAdaptor::SubgroupBallotKHROpAdaptor(SubgroupBallotKHROp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> SubgroupBallotKHROpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange SubgroupBallotKHROpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SubgroupBallotKHROpAdaptor::predicate() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult SubgroupBallotKHROpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef SubgroupBallotKHROp::getOperationName() {
  return "spv.SubgroupBallotKHR";
}

std::pair<unsigned, unsigned> SubgroupBallotKHROp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range SubgroupBallotKHROp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SubgroupBallotKHROp::predicate() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange SubgroupBallotKHROp::predicateMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> SubgroupBallotKHROp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range SubgroupBallotKHROp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value SubgroupBallotKHROp::result() {
  return *getODSResults(0).begin();
}

void SubgroupBallotKHROp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value predicate) {
  odsState.addOperands(predicate);
  odsState.addTypes(result);
}

void SubgroupBallotKHROp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value predicate) {
  odsState.addOperands(predicate);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void SubgroupBallotKHROp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult SubgroupBallotKHROp::verify() {
  if (failed(SubgroupBallotKHROpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isSignlessInteger(1)))) {
        return emitOpError("operand #") << index << " must be bool, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32)))) && (((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) {
        return emitOpError("result #") << index << " must be vector of 32-bit integer values of length 4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









::mlir::ParseResult SubgroupBallotKHROp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::OpAsmParser::OperandType predicateRawOperands[1];
  ::llvm::ArrayRef<::mlir::OpAsmParser::OperandType> predicateOperands(predicateRawOperands);  ::llvm::SMLoc predicateOperandsLoc = parser.getCurrentLocation();
  (void)predicateOperandsLoc;
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);

  if (parser.parseOperand(predicateRawOperands[0]))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  ::mlir::Type odsBuildableType0 = parser.getBuilder().getIntegerType(1);
  result.addTypes(resultTypes);
  if (parser.resolveOperands(predicateOperands, odsBuildableType0, result.operands))
    return failure();
  return success();
}

void SubgroupBallotKHROp::print(OpAsmPrinter &p) {
  p << "spv.SubgroupBallotKHR";
  p << " ";
  p << predicate();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}


//===----------------------------------------------------------------------===//
// spirv::TransposeOp definitions
//===----------------------------------------------------------------------===//

TransposeOpAdaptor::TransposeOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

TransposeOpAdaptor::TransposeOpAdaptor(TransposeOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> TransposeOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange TransposeOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value TransposeOpAdaptor::matrix() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult TransposeOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef TransposeOp::getOperationName() {
  return "spv.Transpose";
}

std::pair<unsigned, unsigned> TransposeOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range TransposeOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value TransposeOp::matrix() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange TransposeOp::matrixMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> TransposeOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range TransposeOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value TransposeOp::result() {
  return *getODSResults(0).begin();
}

void TransposeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value matrix) {
  odsState.addOperands(matrix);
  odsState.addTypes(result);
}

void TransposeOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value matrix) {
  odsState.addOperands(matrix);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void TransposeOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult TransposeOp::verify() {
  if (failed(TransposeOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::MatrixType>()))) {
        return emitOpError("operand #") << index << " must be any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::MatrixType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyTranspose(*this);
}









::mlir::ParseResult TransposeOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type matrixRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> matrixTypes(matrixRawTypes);
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);
  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();
  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> allOperands;
  if (parser.parseOperandList(allOperands))
    return failure();
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(matrixRawTypes[0]))
    return failure();
  if (parser.parseArrow())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  result.addTypes(resultTypes);
  if (parser.resolveOperands(allOperands, matrixTypes, allOperandLoc, result.operands))
    return failure();
  return success();
}

void TransposeOp::print(OpAsmPrinter &p) {
  p << "spv.Transpose";
  p << " ";
  p << getOperation()->getOperands();
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(matrix().getType());
  p << " " << "->";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}

void TransposeOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::UConvertOp definitions
//===----------------------------------------------------------------------===//

UConvertOpAdaptor::UConvertOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

UConvertOpAdaptor::UConvertOpAdaptor(UConvertOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> UConvertOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange UConvertOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UConvertOpAdaptor::operand() {
  return *getODSOperands(0).begin();
}

::mlir::LogicalResult UConvertOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef UConvertOp::getOperationName() {
  return "spv.UConvert";
}

std::pair<unsigned, unsigned> UConvertOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range UConvertOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UConvertOp::operand() {
  return *getODSOperands(0).begin();
}

::mlir::MutableOperandRange UConvertOp::operandMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> UConvertOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range UConvertOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UConvertOp::result() {
  return *getODSResults(0).begin();
}

void UConvertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand) {
  odsState.addOperands(operand);
  odsState.addTypes(result);
}

void UConvertOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand) {
  odsState.addOperands(operand);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void UConvertOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 1u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult UConvertOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return mlir::impl::parseCastOp(parser, result);
}

void UConvertOp::print(::mlir::OpAsmPrinter &p) {
  mlir::impl::printCastOp(this->getOperation(), p);
}

::mlir::LogicalResult UConvertOp::verify() {
  if (failed(UConvertOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return verifyCastOp(this->getOperation(), false);
}









void UConvertOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::UDivOp definitions
//===----------------------------------------------------------------------===//

UDivOpAdaptor::UDivOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

UDivOpAdaptor::UDivOpAdaptor(UDivOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> UDivOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange UDivOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UDivOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UDivOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult UDivOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef UDivOp::getOperationName() {
  return "spv.UDiv";
}

std::pair<unsigned, unsigned> UDivOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range UDivOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UDivOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UDivOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange UDivOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange UDivOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> UDivOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range UDivOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UDivOp::result() {
  return *getODSResults(0).begin();
}

void UDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void UDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void UDivOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void UDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void UDivOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult UDivOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void UDivOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult UDivOp::verify() {
  if (failed(UDivOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void UDivOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::UGreaterThanEqualOp definitions
//===----------------------------------------------------------------------===//

UGreaterThanEqualOpAdaptor::UGreaterThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

UGreaterThanEqualOpAdaptor::UGreaterThanEqualOpAdaptor(UGreaterThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> UGreaterThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange UGreaterThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UGreaterThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UGreaterThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult UGreaterThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef UGreaterThanEqualOp::getOperationName() {
  return "spv.UGreaterThanEqual";
}

std::pair<unsigned, unsigned> UGreaterThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range UGreaterThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UGreaterThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UGreaterThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange UGreaterThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange UGreaterThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> UGreaterThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range UGreaterThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UGreaterThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void UGreaterThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void UGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void UGreaterThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void UGreaterThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult UGreaterThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void UGreaterThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult UGreaterThanEqualOp::verify() {
  if (failed(UGreaterThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void UGreaterThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::UGreaterThanOp definitions
//===----------------------------------------------------------------------===//

UGreaterThanOpAdaptor::UGreaterThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

UGreaterThanOpAdaptor::UGreaterThanOpAdaptor(UGreaterThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> UGreaterThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange UGreaterThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UGreaterThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UGreaterThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult UGreaterThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef UGreaterThanOp::getOperationName() {
  return "spv.UGreaterThan";
}

std::pair<unsigned, unsigned> UGreaterThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range UGreaterThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UGreaterThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UGreaterThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange UGreaterThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange UGreaterThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> UGreaterThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range UGreaterThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UGreaterThanOp::result() {
  return *getODSResults(0).begin();
}

void UGreaterThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void UGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void UGreaterThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void UGreaterThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult UGreaterThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void UGreaterThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult UGreaterThanOp::verify() {
  if (failed(UGreaterThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void UGreaterThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ULessThanEqualOp definitions
//===----------------------------------------------------------------------===//

ULessThanEqualOpAdaptor::ULessThanEqualOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ULessThanEqualOpAdaptor::ULessThanEqualOpAdaptor(ULessThanEqualOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ULessThanEqualOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ULessThanEqualOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ULessThanEqualOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ULessThanEqualOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult ULessThanEqualOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ULessThanEqualOp::getOperationName() {
  return "spv.ULessThanEqual";
}

std::pair<unsigned, unsigned> ULessThanEqualOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ULessThanEqualOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ULessThanEqualOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ULessThanEqualOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange ULessThanEqualOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange ULessThanEqualOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ULessThanEqualOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ULessThanEqualOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ULessThanEqualOp::result() {
  return *getODSResults(0).begin();
}

void ULessThanEqualOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void ULessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void ULessThanEqualOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ULessThanEqualOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ULessThanEqualOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void ULessThanEqualOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult ULessThanEqualOp::verify() {
  if (failed(ULessThanEqualOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void ULessThanEqualOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::ULessThanOp definitions
//===----------------------------------------------------------------------===//

ULessThanOpAdaptor::ULessThanOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

ULessThanOpAdaptor::ULessThanOpAdaptor(ULessThanOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> ULessThanOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange ULessThanOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ULessThanOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ULessThanOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult ULessThanOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef ULessThanOp::getOperationName() {
  return "spv.ULessThan";
}

std::pair<unsigned, unsigned> ULessThanOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range ULessThanOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ULessThanOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value ULessThanOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange ULessThanOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange ULessThanOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> ULessThanOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range ULessThanOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value ULessThanOp::result() {
  return *getODSResults(0).begin();
}

void ULessThanOp::build(OpBuilder &builder, OperationState &state, Value lhs, Value rhs) {
::buildLogicalBinaryOp(builder, state, lhs, rhs);
}

void ULessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void ULessThanOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void ULessThanOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult ULessThanOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseLogicalBinaryOp(parser, result);
}

void ULessThanOp::print(::mlir::OpAsmPrinter &p) {
  return ::printLogicalOp(getOperation(), p);
}

::mlir::LogicalResult ULessThanOp::verify() {
  if (failed(ULessThanOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isSignlessInteger(1))) || ((((v.getType().isa<::mlir::VectorType>())) && ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1)))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))))) {
        return emitOpError("result #") << index << " must be bool or vector of bool values of length 2/3/4, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void ULessThanOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::UModOp definitions
//===----------------------------------------------------------------------===//

UModOpAdaptor::UModOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

UModOpAdaptor::UModOpAdaptor(UModOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> UModOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange UModOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UModOpAdaptor::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UModOpAdaptor::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::LogicalResult UModOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef UModOp::getOperationName() {
  return "spv.UMod";
}

std::pair<unsigned, unsigned> UModOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range UModOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UModOp::operand1() {
  return *getODSOperands(0).begin();
}

::mlir::Value UModOp::operand2() {
  return *getODSOperands(1).begin();
}

::mlir::MutableOperandRange UModOp::operand1Mutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

::mlir::MutableOperandRange UModOp::operand2Mutable() {
  auto range = getODSOperandIndexAndLength(1);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> UModOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range UModOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UModOp::result() {
  return *getODSResults(0).begin();
}

void UModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes(result);
}

void UModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void UModOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 2u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

void UModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand1, ::mlir::Value operand2) {
  odsState.addOperands(operand1);
  odsState.addOperands(operand2);
  odsState.addTypes({operand1.getType()});

}

void UModOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  odsState.addTypes({operands[0].getType()});

}

::mlir::ParseResult UModOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return impl::parseOneResultSameOperandTypeOp(parser, result);
}

void UModOp::print(::mlir::OpAsmPrinter &p) {
  return impl::printOneResultOp(getOperation(), p);
}

::mlir::LogicalResult UModOp::verify() {
  if (failed(UModOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
    auto valueGroup1 = getODSOperands(1);
    for (::mlir::Value v : valueGroup1) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("operand #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || (((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) && (((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::spirv::CooperativeMatrixNVType>().getElementType().isInteger(64))))))) {
        return emitOpError("result #") << index << " must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4 or Cooperative Matrix of 8/16/32/64-bit integer values, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









void UModOp::getEffects(::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) {

}


//===----------------------------------------------------------------------===//
// spirv::UndefOp definitions
//===----------------------------------------------------------------------===//

UndefOpAdaptor::UndefOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

UndefOpAdaptor::UndefOpAdaptor(UndefOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> UndefOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange UndefOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::LogicalResult UndefOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef UndefOp::getOperationName() {
  return "spv.undef";
}

std::pair<unsigned, unsigned> UndefOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range UndefOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> UndefOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range UndefOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value UndefOp::result() {
  return *getODSResults(0).begin();
}

void UndefOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type result) {
  odsState.addTypes(result);
}

void UndefOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes) {
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void UndefOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult UndefOp::verify() {
  if (failed(UndefOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!(((v.getType().isa<::mlir::NoneType>())) || ((v.getType().isSignlessInteger(1))) || (((v.getType().isInteger(8))) || ((v.getType().isInteger(16))) || ((v.getType().isInteger(32))) || ((v.getType().isInteger(64)))) || (((v.getType().isF16())) || ((v.getType().isF32())) || ((v.getType().isF64()))) || ((((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(1))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(8))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(16))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(32))) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isInteger(64)))) || (((v.getType().cast<::mlir::ShapedType>().getElementType().isF16())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isF64()))))) && (((v.getType().isa<::mlir::VectorType>())) && (((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 2)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 3)) || ((v.getType().cast<::mlir::VectorType>().getNumElements()
                           == 4))))) || ((v.getType().isa<::mlir::spirv::PointerType>())) || ((v.getType().isa<::mlir::spirv::ArrayType>())) || ((v.getType().isa<::mlir::spirv::RuntimeArrayType>())) || ((v.getType().isa<::mlir::spirv::StructType>())) || ((v.getType().isa<::mlir::spirv::CooperativeMatrixNVType>())) || ((v.getType().isa<::mlir::spirv::MatrixType>())))) {
        return emitOpError("result #") << index << " must be void or bool or 8/16/32/64-bit integer or 16/32/64-bit float or vector of bool or 8/16/32/64-bit integer or 16/32/64-bit float values of length 2/3/4 or any SPIR-V pointer type or any SPIR-V array type or any SPIR-V runtime array type or any SPIR-V struct type or any SPIR-V cooperative matrix type or any SPIR-V matrix type, but got " << v.getType();
      }
      ++index;
    }
  }
  return success();
}









::mlir::ParseResult UndefOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  ::mlir::Type resultRawTypes[1];
  ::llvm::ArrayRef<::mlir::Type> resultTypes(resultRawTypes);
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  if (parser.parseColon())
    return failure();

  if (parser.parseType(resultRawTypes[0]))
    return failure();
  result.addTypes(resultTypes);
  return success();
}

void UndefOp::print(OpAsmPrinter &p) {
  p << "spv.undef";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
  p << " " << ":";
  p << " ";
  p << ::llvm::ArrayRef<::mlir::Type>(result().getType());
}


//===----------------------------------------------------------------------===//
// spirv::UnreachableOp definitions
//===----------------------------------------------------------------------===//

UnreachableOpAdaptor::UnreachableOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

UnreachableOpAdaptor::UnreachableOpAdaptor(UnreachableOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> UnreachableOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::ValueRange UnreachableOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::LogicalResult UnreachableOpAdaptor::verify(::mlir::Location loc) {
  return success();
}

::llvm::StringRef UnreachableOp::getOperationName() {
  return "spv.Unreachable";
}

std::pair<unsigned, unsigned> UnreachableOp::getODSOperandIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::operand_range UnreachableOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

std::pair<unsigned, unsigned> UnreachableOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range UnreachableOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

void UnreachableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState) {

}

void UnreachableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes) {
  assert(resultTypes.size() == 0u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void UnreachableOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  assert(operands.size() == 0u && "mismatched number of parameters");
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 0u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::LogicalResult UnreachableOp::verify() {
  if (failed(UnreachableOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
  }
  {
    unsigned index = 0; (void)index;
  }
  if (!((isNestedInFunctionLikeOp((*this->getOperation()).getParentOp()))))
    return emitOpError("failed to verify that op must appear in a function-like op's block");
  return ::verify(*this);
}









::mlir::ParseResult UnreachableOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
  return success();
}

void UnreachableOp::print(OpAsmPrinter &p) {
  p << "spv.Unreachable";
  p.printOptionalAttrDict(getAttrs(), /*elidedAttrs=*/{});
}


//===----------------------------------------------------------------------===//
// spirv::VariableOp definitions
//===----------------------------------------------------------------------===//

VariableOpAdaptor::VariableOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs )  : odsOperands(values), odsAttrs(attrs) {

}

VariableOpAdaptor::VariableOpAdaptor(VariableOp& op)  : odsOperands(op.getOperation()->getOperands()), odsAttrs(op.getOperation()->getAttrDictionary()) {

}

std::pair<unsigned, unsigned> VariableOpAdaptor::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (odsOperands.size() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::ValueRange VariableOpAdaptor::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(odsOperands.begin(), valueRange.first),
           std::next(odsOperands.begin(), valueRange.first + valueRange.second)};
}

::mlir::Value VariableOpAdaptor::initializer() {
  auto operands = getODSOperands(0);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::IntegerAttr VariableOpAdaptor::storage_class() {
  assert(odsAttrs && "no attributes when constructing adapter");
  ::mlir::IntegerAttr attr = odsAttrs.get("storage_class").cast<::mlir::IntegerAttr>();
  return attr;
}

::mlir::LogicalResult VariableOpAdaptor::verify(::mlir::Location loc) {
  {
  auto tblgen_storage_class = odsAttrs.get("storage_class");
  if (!tblgen_storage_class) return emitError(loc, "'spv.Variable' op ""requires attribute 'storage_class'");
    if (!((((tblgen_storage_class.isa<::mlir::IntegerAttr>())) && ((tblgen_storage_class.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))) && ((::mlir::spirv::symbolizeStorageClass(tblgen_storage_class.cast<IntegerAttr>().getValue().getZExtValue()).hasValue())))) return emitError(loc, "'spv.Variable' op ""attribute 'storage_class' failed to satisfy constraint: valid SPIR-V StorageClass");
  }
  return success();
}

::llvm::StringRef VariableOp::getOperationName() {
  return "spv.Variable";
}

std::pair<unsigned, unsigned> VariableOp::getODSOperandIndexAndLength(unsigned index) {
  bool isVariadic[] = {true};
  int prevVariadicCount = 0;
  for (unsigned i = 0; i < index; ++i)
    if (isVariadic[i]) ++prevVariadicCount;

  // Calculate how many dynamic values a static variadic operand corresponds to.
  // This assumes all static variadic operands have the same dynamic value count.
  int variadicSize = (getOperation()->getNumOperands() - 0) / 1;
  // `index` passed in as the parameter is the static index which counts each
  // operand (variadic or not) as size 1. So here for each previous static variadic
  // operand, we need to offset by (variadicSize - 1) to get where the dynamic
  // value pack for this static operand starts.
  int start = index + (variadicSize - 1) * prevVariadicCount;
  int size = isVariadic[index] ? variadicSize : 1;
  return {start, size};
}

::mlir::Operation::operand_range VariableOp::getODSOperands(unsigned index) {
  auto valueRange = getODSOperandIndexAndLength(index);
  return {std::next(getOperation()->operand_begin(), valueRange.first),
           std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value VariableOp::initializer() {
  auto operands = getODSOperands(0);
  return operands.empty() ? Value() : *operands.begin();
}

::mlir::MutableOperandRange VariableOp::initializerMutable() {
  auto range = getODSOperandIndexAndLength(0);
  return ::mlir::MutableOperandRange(getOperation(), range.first, range.second);
}

std::pair<unsigned, unsigned> VariableOp::getODSResultIndexAndLength(unsigned index) {
  return {index, 1};
}

::mlir::Operation::result_range VariableOp::getODSResults(unsigned index) {
  auto valueRange = getODSResultIndexAndLength(index);
  return {std::next(getOperation()->result_begin(), valueRange.first),
           std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)};
}

::mlir::Value VariableOp::pointer() {
  return *getODSResults(0).begin();
}

::mlir::IntegerAttr VariableOp::storage_classAttr() {
  return this->getAttr("storage_class").cast<::mlir::IntegerAttr>();
}

::mlir::spirv::StorageClass VariableOp::storage_class() {
  auto attr = storage_classAttr();
  return static_cast<::mlir::spirv::StorageClass>(attr.getInt());
}

void VariableOp::storage_classAttr(::mlir::IntegerAttr attr) {
  this->getOperation()->setAttr("storage_class", attr);
}

void VariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type pointer, ::mlir::IntegerAttr storage_class, /*optional*/::mlir::Value initializer) {
  if (initializer)
    odsState.addOperands(initializer);
  odsState.addAttribute("storage_class", storage_class);
  odsState.addTypes(pointer);
}

void VariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::IntegerAttr storage_class, /*optional*/::mlir::Value initializer) {
  if (initializer)
    odsState.addOperands(initializer);
  odsState.addAttribute("storage_class", storage_class);
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void VariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type pointer, ::mlir::spirv::StorageClass storage_class, /*optional*/::mlir::Value initializer) {
  if (initializer)
    odsState.addOperands(initializer);
  odsState.addAttribute("storage_class", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(storage_class)));
  odsState.addTypes(pointer);
}

void VariableOp::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::spirv::StorageClass storage_class, /*optional*/::mlir::Value initializer) {
  if (initializer)
    odsState.addOperands(initializer);
  odsState.addAttribute("storage_class", odsBuilder.getI32IntegerAttr(static_cast<int32_t>(storage_class)));
  assert(resultTypes.size() == 1u && "mismatched number of results");
  odsState.addTypes(resultTypes);
}

void VariableOp::build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes ) {
  odsState.addOperands(operands);
  odsState.addAttributes(attributes);
  assert(resultTypes.size() == 1u && "mismatched number of return types");
  odsState.addTypes(resultTypes);
}

::mlir::ParseResult VariableOp::parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result) {
  return ::parseVariableOp(parser, result);
}

void VariableOp::print(::mlir::OpAsmPrinter &p) {
  return ::print(*this, p);
}

::mlir::LogicalResult VariableOp::verify() {
  if (failed(VariableOpAdaptor(*this).verify(this->getLoc()))) return failure();
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSOperands(0);
    if (valueGroup0.size() > 1)
      return emitOpError("operand group starting at #") << index << " requires 0 or 1 element, but found " << valueGroup0.size();
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((true))) {
        return emitOpError("operand #") << index << " must be any type, but got " << v.getType();
      }
      ++index;
    }
  }
  {
    unsigned index = 0; (void)index;
    auto valueGroup0 = getODSResults(0);
    for (::mlir::Value v : valueGroup0) {
      (void)v;
      if (!((v.getType().isa<::mlir::spirv::PointerType>()))) {
        return emitOpError("result #") << index << " must be any SPIR-V pointer type, but got " << v.getType();
      }
      ++index;
    }
  }
  return ::verify(*this);
}










#endif  // GET_OP_CLASSES

