/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\

|*                                                                            *|

|* Op Declarations                                                            *|

|*                                                                            *|

|* Automatically generated file, do not edit!                                 *|

|*                                                                            *|

\*===----------------------------------------------------------------------===*/

#ifdef GET_OP_CLASSES

#undef GET_OP_CLASSES

class AbsFOp;

class AddCFOp;

class AddFOp;

class AddIOp;

class AllocOp;

class AllocaOp;

class AndOp;

class AssumeAlignmentOp;

class AtomicRMWOp;

class AtomicYieldOp;

class BranchOp;

class CallIndirectOp;

class CallOp;

class CeilFOp;

class CmpFOp;

class CmpIOp;

class CondBranchOp;

class ConstantOp;

class CopySignOp;

class CosOp;

class CreateComplexOp;

class DeallocOp;

class DimOp;

class DivFOp;

class Exp2Op;

class ExpOp;

class ExtractElementOp;

class FPExtOp;

class FPToSIOp;

class FPTruncOp;

class GenericAtomicRMWOp;

class ImOp;

class IndexCastOp;

class LoadOp;

class Log10Op;

class Log2Op;

class LogOp;

class MemRefCastOp;

class MulFOp;

class MulIOp;

class NegFOp;

class OrOp;

class PrefetchOp;

class RankOp;

class ReOp;

class RemFOp;

class ReturnOp;

class RsqrtOp;

class SIToFPOp;

class SelectOp;

class ShiftLeftOp;

class SignExtendIOp;

class SignedDivIOp;

class SignedRemIOp;

class SignedShiftRightOp;

class SinOp;

class SplatOp;

class SqrtOp;

class StoreOp;

class SubCFOp;

class SubFOp;

class SubIOp;

class SubViewOp;

class TanhOp;

class TensorCastOp;

class TensorFromElementsOp;

class TensorLoadOp;

class TensorStoreOp;

class TruncateIOp;

class UnsignedDivIOp;

class UnsignedRemIOp;

class UnsignedShiftRightOp;

class ViewOp;

class XOrOp;

class ZeroExtendIOp;

//===----------------------------------------------------------------------===//

// AbsFOp declarations

//===----------------------------------------------------------------------===//

class AbsFOpOperandAdaptor {

public:

  AbsFOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AbsFOpOperandAdaptor(AbsFOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value operand();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AbsFOp : public Op<AbsFOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::OneOperand, OpTrait::SameOperandsAndResultType, MemoryEffectOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = AbsFOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value operand();

  ::mlir::MutableOperandRange operandMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value operand);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value operand);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value operand);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// AddCFOp declarations

//===----------------------------------------------------------------------===//

class AddCFOpOperandAdaptor {

public:

  AddCFOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AddCFOpOperandAdaptor(AddCFOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AddCFOp : public Op<AddCFOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::NOperands<2>::Impl, MemoryEffectOpInterface::Trait, OpTrait::SameOperandsAndResultType> {

public:

  using Op::Op;

  using OperandAdaptor = AddCFOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  ::mlir::MutableOperandRange lhsMutable();

  ::mlir::MutableOperandRange rhsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value lhs, Value rhs);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// AddFOp declarations

//===----------------------------------------------------------------------===//

class AddFOpOperandAdaptor {

public:

  AddFOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AddFOpOperandAdaptor(AddFOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AddFOp : public Op<AddFOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::NOperands<2>::Impl, MemoryEffectOpInterface::Trait, OpTrait::SameOperandsAndResultType> {

public:

  using Op::Op;

  using OperandAdaptor = AddFOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  ::mlir::MutableOperandRange lhsMutable();

  ::mlir::MutableOperandRange rhsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value lhs, Value rhs);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  OpFoldResult fold(ArrayRef<Attribute> operands);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// AddIOp declarations

//===----------------------------------------------------------------------===//

class AddIOpOperandAdaptor {

public:

  AddIOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AddIOpOperandAdaptor(AddIOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AddIOp : public Op<AddIOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::NOperands<2>::Impl, OpTrait::IsCommutative, MemoryEffectOpInterface::Trait, OpTrait::SameOperandsAndResultType> {

public:

  using Op::Op;

  using OperandAdaptor = AddIOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  ::mlir::MutableOperandRange lhsMutable();

  ::mlir::MutableOperandRange rhsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value lhs, Value rhs);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  OpFoldResult fold(ArrayRef<Attribute> operands);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// AllocOp declarations

//===----------------------------------------------------------------------===//

class AllocOpOperandAdaptor {

public:

  AllocOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AllocOpOperandAdaptor(AllocOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  ValueRange value();

  IntegerAttr alignment();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AllocOp : public Op<AllocOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::VariadicOperands, MemoryEffectOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = AllocOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Operation::operand_range value();

  ::mlir::MutableOperandRange valueMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  IntegerAttr alignmentAttr();

  Optional< APInt > alignment();

  void alignmentAttr(IntegerAttr attr);

  static void build(OpBuilder &builder, OperationState &result, MemRefType memrefType);

  static void build(OpBuilder &builder, OperationState &result, MemRefType memrefType, ValueRange operands, IntegerAttr alignment = IntegerAttr());

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, ValueRange value, /*optional*/IntegerAttr alignment);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange value, /*optional*/IntegerAttr alignment);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

    static StringRef getAlignmentAttrName() { return "alignment"; }

    MemRefType getType() { return getResult().getType().cast<MemRefType>(); }

    /// Returns the number of symbolic operands (the ones in square brackets),

    /// which bind to the symbols of the memref's layout map.

    unsigned getNumSymbolicOperands() {

      return getNumOperands() - getType().getNumDynamicDims();

    }

    /// Returns the symbolic operands (the ones in square brackets), which bind

    /// to the symbols of the memref's layout map.

    operand_range getSymbolicOperands() {

      return {operand_begin() + getType().getNumDynamicDims(), operand_end()};

    }

    /// Returns the dynamic sizes for this alloc operation if specified.

    operand_range getDynamicSizes() { return getOperands(); }

};

//===----------------------------------------------------------------------===//

// AllocaOp declarations

//===----------------------------------------------------------------------===//

class AllocaOpOperandAdaptor {

public:

  AllocaOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AllocaOpOperandAdaptor(AllocaOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  ValueRange value();

  IntegerAttr alignment();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AllocaOp : public Op<AllocaOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::VariadicOperands, MemoryEffectOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = AllocaOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Operation::operand_range value();

  ::mlir::MutableOperandRange valueMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  IntegerAttr alignmentAttr();

  Optional< APInt > alignment();

  void alignmentAttr(IntegerAttr attr);

  static void build(OpBuilder &builder, OperationState &result, MemRefType memrefType);

  static void build(OpBuilder &builder, OperationState &result, MemRefType memrefType, ValueRange operands, IntegerAttr alignment = IntegerAttr());

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, ValueRange value, /*optional*/IntegerAttr alignment);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange value, /*optional*/IntegerAttr alignment);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

    static StringRef getAlignmentAttrName() { return "alignment"; }

    MemRefType getType() { return getResult().getType().cast<MemRefType>(); }

    /// Returns the number of symbolic operands (the ones in square brackets),

    /// which bind to the symbols of the memref's layout map.

    unsigned getNumSymbolicOperands() {

      return getNumOperands() - getType().getNumDynamicDims();

    }

    /// Returns the symbolic operands (the ones in square brackets), which bind

    /// to the symbols of the memref's layout map.

    operand_range getSymbolicOperands() {

      return {operand_begin() + getType().getNumDynamicDims(), operand_end()};

    }

    /// Returns the dynamic sizes for this alloc operation if specified.

    operand_range getDynamicSizes() { return getOperands(); }

};

//===----------------------------------------------------------------------===//

// AndOp declarations

//===----------------------------------------------------------------------===//

class AndOpOperandAdaptor {

public:

  AndOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AndOpOperandAdaptor(AndOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AndOp : public Op<AndOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::NOperands<2>::Impl, OpTrait::IsCommutative, MemoryEffectOpInterface::Trait, OpTrait::SameOperandsAndResultType> {

public:

  using Op::Op;

  using OperandAdaptor = AndOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  ::mlir::MutableOperandRange lhsMutable();

  ::mlir::MutableOperandRange rhsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value lhs, Value rhs);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  OpFoldResult fold(ArrayRef<Attribute> operands);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// AssumeAlignmentOp declarations

//===----------------------------------------------------------------------===//

class AssumeAlignmentOpOperandAdaptor {

public:

  AssumeAlignmentOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AssumeAlignmentOpOperandAdaptor(AssumeAlignmentOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value memref();

  IntegerAttr alignment();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AssumeAlignmentOp : public Op<AssumeAlignmentOp, OpTrait::ZeroRegion, OpTrait::ZeroResult, OpTrait::ZeroSuccessor, OpTrait::OneOperand> {

public:

  using Op::Op;

  using OperandAdaptor = AssumeAlignmentOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value memref();

  ::mlir::MutableOperandRange memrefMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  IntegerAttr alignmentAttr();

  APInt alignment();

  void alignmentAttr(IntegerAttr attr);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value memref, IntegerAttr alignment);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value memref, IntegerAttr alignment);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value memref, APInt alignment);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value memref, APInt alignment);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

};

//===----------------------------------------------------------------------===//

// AtomicRMWOp declarations

//===----------------------------------------------------------------------===//

class AtomicRMWOpOperandAdaptor {

public:

  AtomicRMWOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AtomicRMWOpOperandAdaptor(AtomicRMWOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value value();

  Value memref();

  ValueRange indices();

  IntegerAttr kind();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AtomicRMWOp : public Op<AtomicRMWOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<2>::Impl> {

public:

  using Op::Op;

  using OperandAdaptor = AtomicRMWOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value value();

  Value memref();

  Operation::operand_range indices();

  ::mlir::MutableOperandRange valueMutable();

  ::mlir::MutableOperandRange memrefMutable();

  ::mlir::MutableOperandRange indicesMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  Value result();

  IntegerAttr kindAttr();

  ::mlir::AtomicRMWKind kind();

  void kindAttr(IntegerAttr attr);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type result, IntegerAttr kind, Value value, Value memref, ValueRange indices);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, IntegerAttr kind, Value value, Value memref, ValueRange indices);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type result, ::mlir::AtomicRMWKind kind, Value value, Value memref, ValueRange indices);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, ::mlir::AtomicRMWKind kind, Value value, Value memref, ValueRange indices);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

    MemRefType getMemRefType() {

      return memref().getType().cast<MemRefType>();

    }

};

//===----------------------------------------------------------------------===//

// AtomicYieldOp declarations

//===----------------------------------------------------------------------===//

class AtomicYieldOpOperandAdaptor {

public:

  AtomicYieldOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  AtomicYieldOpOperandAdaptor(AtomicYieldOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value result();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class AtomicYieldOp : public Op<AtomicYieldOp, OpTrait::ZeroRegion, OpTrait::ZeroResult, OpTrait::ZeroSuccessor, OpTrait::OneOperand, OpTrait::HasParent<GenericAtomicRMWOp>::Impl, MemoryEffectOpInterface::Trait, OpTrait::IsTerminator> {

public:

  using Op::Op;

  using OperandAdaptor = AtomicYieldOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value result();

  ::mlir::MutableOperandRange resultMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value result);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value result);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// BranchOp declarations

//===----------------------------------------------------------------------===//

class BranchOpOperandAdaptor {

public:

  BranchOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  BranchOpOperandAdaptor(BranchOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  ValueRange destOperands();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class BranchOp : public Op<BranchOp, OpTrait::ZeroRegion, OpTrait::ZeroResult, OpTrait::OneSuccessor, OpTrait::VariadicOperands, BranchOpInterface::Trait, MemoryEffectOpInterface::Trait, OpTrait::IsTerminator> {

public:

  using Op::Op;

  using OperandAdaptor = BranchOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Operation::operand_range destOperands();

  ::mlir::MutableOperandRange destOperandsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  Block *dest();

  static void build(OpBuilder &, OperationState &result, Block *dest, ValueRange destOperands = {});

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange destOperands, Block *dest);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange destOperands, Block *dest);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);

  Optional<MutableOperandRange> getMutableSuccessorOperands(unsigned index);

  Block *getSuccessorForOperands(ArrayRef<Attribute> operands);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

    Block *getDest();

    void setDest(Block *block);

    /// Erase the operand at 'index' from the operand list.

    void eraseOperand(unsigned index);

};

//===----------------------------------------------------------------------===//

// CallIndirectOp declarations

//===----------------------------------------------------------------------===//

class CallIndirectOpOperandAdaptor {

public:

  CallIndirectOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CallIndirectOpOperandAdaptor(CallIndirectOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value callee();

  ValueRange operands();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CallIndirectOp : public Op<CallIndirectOp, OpTrait::ZeroRegion, OpTrait::VariadicResults, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, CallOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = CallIndirectOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value callee();

  Operation::operand_range operands();

  ::mlir::MutableOperandRange calleeMutable();

  ::mlir::MutableOperandRange operandsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  Operation::result_range results();

  static void build(OpBuilder &, OperationState &result, Value callee,ValueRange operands = {});

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> results, Value callee, ValueRange operands);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

    Value getCallee() { return getOperand(0); }

    /// Get the argument operands to the called function.

    operand_range getArgOperands() {

      return {arg_operand_begin(), arg_operand_end()};

    }

    operand_iterator arg_operand_begin() { return ++operand_begin(); }

    operand_iterator arg_operand_end() { return operand_end(); }

    /// Return the callee of this operation.

    CallInterfaceCallable getCallableForCallee() { return getCallee(); }

};

//===----------------------------------------------------------------------===//

// CallOp declarations

//===----------------------------------------------------------------------===//

class CallOpOperandAdaptor {

public:

  CallOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CallOpOperandAdaptor(CallOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  ValueRange operands();

  FlatSymbolRefAttr callee();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CallOp : public Op<CallOp, OpTrait::ZeroRegion, OpTrait::VariadicResults, OpTrait::ZeroSuccessor, OpTrait::VariadicOperands, CallOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = CallOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Operation::operand_range operands();

  ::mlir::MutableOperandRange operandsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  FlatSymbolRefAttr calleeAttr();

  StringRef callee();

  void calleeAttr(FlatSymbolRefAttr attr);

  static void build(OpBuilder &builder, OperationState &result, FuncOp callee,ValueRange operands = {});

  static void build(OpBuilder &builder, OperationState &result, SymbolRefAttr callee,ArrayRef<Type> results, ValueRange operands = {});

  static void build(OpBuilder &builder, OperationState &result, StringRef callee,ArrayRef<Type> results, ValueRange operands = {});

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultType0, FlatSymbolRefAttr callee, ValueRange operands);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultType0, StringRef callee, ValueRange operands);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

    StringRef getCallee() { return callee(); }

    FunctionType getCalleeType();

    /// Get the argument operands to the called function.

    operand_range getArgOperands() {

      return {arg_operand_begin(), arg_operand_end()};

    }

    operand_iterator arg_operand_begin() { return operand_begin(); }

    operand_iterator arg_operand_end() { return operand_end(); }

    /// Return the callee of this operation.

    CallInterfaceCallable getCallableForCallee() {

      return getAttrOfType<SymbolRefAttr>("callee");

    }

};

//===----------------------------------------------------------------------===//

// CeilFOp declarations

//===----------------------------------------------------------------------===//

class CeilFOpOperandAdaptor {

public:

  CeilFOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CeilFOpOperandAdaptor(CeilFOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value operand();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CeilFOp : public Op<CeilFOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::OneOperand, OpTrait::SameOperandsAndResultType, MemoryEffectOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = CeilFOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value operand();

  ::mlir::MutableOperandRange operandMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value operand);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value operand);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value operand);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// CmpFOp declarations

//===----------------------------------------------------------------------===//

class CmpFOpOperandAdaptor {

public:

  CmpFOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CmpFOpOperandAdaptor(CmpFOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  IntegerAttr predicate();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CmpFOp : public Op<CmpFOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::NOperands<2>::Impl, MemoryEffectOpInterface::Trait, OpTrait::SameTypeOperands, OpTrait::SameOperandsAndResultShape> {

public:

  using Op::Op;

  using OperandAdaptor = CmpFOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  ::mlir::MutableOperandRange lhsMutable();

  ::mlir::MutableOperandRange rhsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  Value result();

  IntegerAttr predicateAttr();

  ::mlir::CmpFPredicate predicate();

  void predicateAttr(IntegerAttr attr);

  static void build(OpBuilder &builder, OperationState &result, CmpFPredicate predicate,Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type result, IntegerAttr predicate, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, IntegerAttr predicate, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type result, ::mlir::CmpFPredicate predicate, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, ::mlir::CmpFPredicate predicate, Value lhs, Value rhs);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  OpFoldResult fold(ArrayRef<Attribute> operands);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

    static StringRef getPredicateAttrName() { return "predicate"; }

    static CmpFPredicate getPredicateByName(StringRef name);

    CmpFPredicate getPredicate() {

      return (CmpFPredicate)getAttrOfType<IntegerAttr>(getPredicateAttrName())

          .getInt();

    }

};

//===----------------------------------------------------------------------===//

// CmpIOp declarations

//===----------------------------------------------------------------------===//

class CmpIOpOperandAdaptor {

public:

  CmpIOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CmpIOpOperandAdaptor(CmpIOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  IntegerAttr predicate();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CmpIOp : public Op<CmpIOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::NOperands<2>::Impl, MemoryEffectOpInterface::Trait, OpTrait::SameTypeOperands, OpTrait::SameOperandsAndResultShape> {

public:

  using Op::Op;

  using OperandAdaptor = CmpIOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  ::mlir::MutableOperandRange lhsMutable();

  ::mlir::MutableOperandRange rhsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  Value result();

  IntegerAttr predicateAttr();

  ::mlir::CmpIPredicate predicate();

  void predicateAttr(IntegerAttr attr);

  static void build(OpBuilder &builder, OperationState &result, CmpIPredicate predicate,Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type result, IntegerAttr predicate, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, IntegerAttr predicate, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type result, ::mlir::CmpIPredicate predicate, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, ::mlir::CmpIPredicate predicate, Value lhs, Value rhs);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  OpFoldResult fold(ArrayRef<Attribute> operands);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

    static StringRef getPredicateAttrName() { return "predicate"; }

    static CmpIPredicate getPredicateByName(StringRef name);

    CmpIPredicate getPredicate() {

      return (CmpIPredicate)getAttrOfType<IntegerAttr>(getPredicateAttrName())

          .getInt();

    }

};

//===----------------------------------------------------------------------===//

// CondBranchOp declarations

//===----------------------------------------------------------------------===//

class CondBranchOpOperandAdaptor {

public:

  CondBranchOpOperandAdaptor(ValueRange values, DictionaryAttr attrs);

  CondBranchOpOperandAdaptor(CondBranchOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value condition();

  ValueRange trueDestOperands();

  ValueRange falseDestOperands();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CondBranchOp : public Op<CondBranchOp, OpTrait::ZeroRegion, OpTrait::ZeroResult, OpTrait::NSuccessors<2>::Impl, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::AttrSizedOperandSegments, BranchOpInterface::Trait, MemoryEffectOpInterface::Trait, OpTrait::IsTerminator> {

public:

  using Op::Op;

  using OperandAdaptor = CondBranchOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value condition();

  Operation::operand_range trueDestOperands();

  Operation::operand_range falseDestOperands();

  ::mlir::MutableOperandRange conditionMutable();

  ::mlir::MutableOperandRange trueDestOperandsMutable();

  ::mlir::MutableOperandRange falseDestOperandsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  Block *trueDest();

  Block *falseDest();

  static void build(OpBuilder &builder, OperationState &result, Value condition,Block *trueDest, ValueRange trueOperands,Block *falseDest, ValueRange falseOperands);

  static void build(OpBuilder &builder, OperationState &result, Value condition,Block *trueDest, Block *falseDest, ValueRange falseOperands = {});

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value condition, ValueRange trueDestOperands, ValueRange falseDestOperands, Block *trueDest, Block *falseDest);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value condition, ValueRange trueDestOperands, ValueRange falseDestOperands, Block *trueDest, Block *falseDest);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  LogicalResult verify();

  static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);

  Optional<MutableOperandRange> getMutableSuccessorOperands(unsigned index);

  Block *getSuccessorForOperands(ArrayRef<Attribute> operands);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

    // These are the indices into the dests list.

    enum { trueIndex = 0, falseIndex = 1 };

    // The condition operand is the first operand in the list.

    Value getCondition() { return getOperand(0); }

    /// Return the destination if the condition is true.

    Block *getTrueDest() {

      return getSuccessor(trueIndex);

    }

    /// Return the destination if the condition is false.

    Block *getFalseDest() {

      return getSuccessor(falseIndex);

    }

    // Accessors for operands to the 'true' destination.

    Value getTrueOperand(unsigned idx) {

      assert(idx < getNumTrueOperands());

      return getOperand(getTrueDestOperandIndex() + idx);

    }

    void setTrueOperand(unsigned idx, Value value) {

      assert(idx < getNumTrueOperands());

      setOperand(getTrueDestOperandIndex() + idx, value);

    }

    operand_range getTrueOperands() { return trueDestOperands(); }

    unsigned getNumTrueOperands()  { return getTrueOperands().size(); }

    /// Erase the operand at 'index' from the true operand list.

    void eraseTrueOperand(unsigned index)  {

      trueDestOperandsMutable().erase(index);

    }

    // Accessors for operands to the 'false' destination.

    Value getFalseOperand(unsigned idx) {

      assert(idx < getNumFalseOperands());

      return getOperand(getFalseDestOperandIndex() + idx);

    }

    void setFalseOperand(unsigned idx, Value value) {

      assert(idx < getNumFalseOperands());

      setOperand(getFalseDestOperandIndex() + idx, value);

    }

    operand_range getFalseOperands() { return falseDestOperands(); }

    unsigned getNumFalseOperands() { return getFalseOperands().size(); }

    /// Erase the operand at 'index' from the false operand list.

    void eraseFalseOperand(unsigned index) {

      falseDestOperandsMutable().erase(index);

    }

  private:

    /// Get the index of the first true destination operand.

    unsigned getTrueDestOperandIndex() { return 1; }

    /// Get the index of the first false destination operand.

    unsigned getFalseDestOperandIndex() {

      return getTrueDestOperandIndex() + getNumTrueOperands();

    }

};

//===----------------------------------------------------------------------===//

// ConstantOp declarations

//===----------------------------------------------------------------------===//

class ConstantOpOperandAdaptor {

public:

  ConstantOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  ConstantOpOperandAdaptor(ConstantOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Attribute value();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class ConstantOp : public Op<ConstantOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::ZeroOperands, OpTrait::ConstantLike, MemoryEffectOpInterface::Trait, OpAsmOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = ConstantOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  Attribute valueAttr();

  Attribute value();

  void valueAttr(Attribute attr);

  static void build(OpBuilder &builder, OperationState &result, Attribute value);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Attribute value);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Attribute value);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  OpFoldResult fold(ArrayRef<Attribute> operands);

  void getAsmResultNames(OpAsmSetValueNameFn setNameFn);

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

    Attribute getValue() { return getAttr("value"); }

    /// Returns true if a constant operation can be built with the given value

    /// and result type.

    static bool isBuildableWith(Attribute value, Type type);

};

//===----------------------------------------------------------------------===//

// CopySignOp declarations

//===----------------------------------------------------------------------===//

class CopySignOpOperandAdaptor {

public:

  CopySignOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CopySignOpOperandAdaptor(CopySignOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CopySignOp : public Op<CopySignOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::NOperands<2>::Impl, MemoryEffectOpInterface::Trait, OpTrait::SameOperandsAndResultType> {

public:

  using Op::Op;

  using OperandAdaptor = CopySignOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value lhs();

  Value rhs();

  ::mlir::MutableOperandRange lhsMutable();

  ::mlir::MutableOperandRange rhsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value lhs, Value rhs);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value lhs, Value rhs);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// CosOp declarations

//===----------------------------------------------------------------------===//

class CosOpOperandAdaptor {

public:

  CosOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CosOpOperandAdaptor(CosOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value operand();

private:

  ValueRange odsOperands;

  DictionaryAttr odsAttrs;

};

class CosOp : public Op<CosOp, OpTrait::ZeroRegion, OpTrait::OneResult, OpTrait::ZeroSuccessor, OpTrait::OneOperand, OpTrait::SameOperandsAndResultType, MemoryEffectOpInterface::Trait> {

public:

  using Op::Op;

  using OperandAdaptor = CosOpOperandAdaptor;

  static StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  Operation::operand_range getODSOperands(unsigned index);

  Value operand();

  ::mlir::MutableOperandRange operandMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  Operation::result_range getODSResults(unsigned index);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Type resultType0, Value operand);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes, Value operand);

  static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, Value operand);

  static void build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes);

  static ParseResult parse(OpAsmParser &parser, OperationState &result);

  void print(OpAsmPrinter &p);

  LogicalResult verify();

  void getEffects(SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects);

};

//===----------------------------------------------------------------------===//

// CreateComplexOp declarations

//===----------------------------------------------------------------------===//

class CreateComplexOpOperandAdaptor {

public:

  CreateComplexOpOperandAdaptor(ValueRange values, DictionaryAttr attrs = nullptr);

  CreateComplexOpOperandAdaptor(CreateComplexOp& op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ValueRange getODSOperands(unsigned index);

  Value real();

  Value imaginary();

private:

  ValueRange odsOperands;