/* Autogenerated by mlir-tblgen; don't manually edit */

#ifdef GEN_PASS_DECL
// Generate declarations for all passes.
#define GEN_PASS_DECL_ARITHBUFFERIZE
#define GEN_PASS_DECL_ARITHEMULATEWIDEINT
#define GEN_PASS_DECL_ARITHEXPANDOPS
#define GEN_PASS_DECL_ARITHINTRANGEOPTS
#define GEN_PASS_DECL_ARITHUNSIGNEDWHENEQUIVALENT
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL

//===----------------------------------------------------------------------===//
// ArithBufferize
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_ARITHBUFFERIZE
struct ArithBufferizeOptions {
  unsigned alignment = 0;
};
#undef GEN_PASS_DECL_ARITHBUFFERIZE
#endif // GEN_PASS_DECL_ARITHBUFFERIZE
#ifdef GEN_PASS_DEF_ARITHBUFFERIZE
namespace impl {

template <typename DerivedT>
class ArithBufferizeBase : public ::mlir::OperationPass<ModuleOp> {
public:
  using Base = ArithBufferizeBase;

  ArithBufferizeBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ArithBufferizeBase(const ArithBufferizeBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-bufferize");
  }
  ::llvm::StringRef getArgument() const override { return "arith-bufferize"; }

  ::llvm::StringRef getDescription() const override { return "Bufferize Arith dialect ops."; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithBufferize");
  }
  ::llvm::StringRef getName() const override { return "ArithBufferize"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithBufferizeBase<DerivedT>)

  ArithBufferizeBase(const ArithBufferizeOptions &options) : ArithBufferizeBase() {
    alignment = options.alignment;
  }
protected:
  ::mlir::Pass::Option<unsigned> alignment{*this, "alignment", ::llvm::cl::desc("Create global memrefs with a specified alignment"), ::llvm::cl::init(0)};
private:
};
} // namespace impl
#undef GEN_PASS_DEF_ARITHBUFFERIZE
#endif // GEN_PASS_DEF_ARITHBUFFERIZE

//===----------------------------------------------------------------------===//
// ArithEmulateWideInt
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_ARITHEMULATEWIDEINT
struct ArithEmulateWideIntOptions {
  unsigned widestIntSupported = 32;
};
std::unique_ptr<::mlir::Pass> createArithEmulateWideInt();
std::unique_ptr<::mlir::Pass> createArithEmulateWideInt(const ArithEmulateWideIntOptions &options);
#undef GEN_PASS_DECL_ARITHEMULATEWIDEINT
#endif // GEN_PASS_DECL_ARITHEMULATEWIDEINT
#ifdef GEN_PASS_DEF_ARITHEMULATEWIDEINT

namespace impl {
  std::unique_ptr<::mlir::Pass> createArithEmulateWideInt();
} // namespace impl

namespace impl {
  std::unique_ptr<::mlir::Pass> createArithEmulateWideInt(const ArithEmulateWideIntOptions &options);
} // namespace impl
namespace impl {

template <typename DerivedT>
class ArithEmulateWideIntBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithEmulateWideIntBase;

  ArithEmulateWideIntBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithEmulateWideIntBase(const ArithEmulateWideIntBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-emulate-wide-int");
  }
  ::llvm::StringRef getArgument() const override { return "arith-emulate-wide-int"; }

  ::llvm::StringRef getDescription() const override { return "Emulate 2*N-bit integer operations using N-bit operations"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithEmulateWideInt");
  }
  ::llvm::StringRef getName() const override { return "ArithEmulateWideInt"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  registry.insert<vector::VectorDialect>();

  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithEmulateWideIntBase<DerivedT>)

  ArithEmulateWideIntBase(const ArithEmulateWideIntOptions &options) : ArithEmulateWideIntBase() {
    widestIntSupported = options.widestIntSupported;
  }
protected:
  ::mlir::Pass::Option<unsigned> widestIntSupported{*this, "widest-int-supported", ::llvm::cl::desc("Widest integer type supported by the target"), ::llvm::cl::init(32)};
private:

  friend std::unique_ptr<::mlir::Pass> createArithEmulateWideInt() {
    return std::make_unique<DerivedT>();
  }

  friend std::unique_ptr<::mlir::Pass> createArithEmulateWideInt(const ArithEmulateWideIntOptions &options) {
    return std::make_unique<DerivedT>(options);
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createArithEmulateWideInt() {
  return impl::createArithEmulateWideInt();
}

std::unique_ptr<::mlir::Pass> createArithEmulateWideInt(const ArithEmulateWideIntOptions &options) {
  return impl::createArithEmulateWideInt(options);
}
#undef GEN_PASS_DEF_ARITHEMULATEWIDEINT
#endif // GEN_PASS_DEF_ARITHEMULATEWIDEINT

//===----------------------------------------------------------------------===//
// ArithExpandOps
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_ARITHEXPANDOPS
#undef GEN_PASS_DECL_ARITHEXPANDOPS
#endif // GEN_PASS_DECL_ARITHEXPANDOPS
#ifdef GEN_PASS_DEF_ARITHEXPANDOPS
namespace impl {

template <typename DerivedT>
class ArithExpandOpsBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithExpandOpsBase;

  ArithExpandOpsBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithExpandOpsBase(const ArithExpandOpsBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-expand");
  }
  ::llvm::StringRef getArgument() const override { return "arith-expand"; }

  ::llvm::StringRef getDescription() const override { return "Legalize Arith ops to be convertible to LLVM."; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithExpandOps");
  }
  ::llvm::StringRef getName() const override { return "ArithExpandOps"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithExpandOpsBase<DerivedT>)

protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_ARITHEXPANDOPS
#endif // GEN_PASS_DEF_ARITHEXPANDOPS

//===----------------------------------------------------------------------===//
// ArithIntRangeOpts
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_ARITHINTRANGEOPTS
std::unique_ptr<::mlir::Pass> createArithIntRangeOpts();
#undef GEN_PASS_DECL_ARITHINTRANGEOPTS
#endif // GEN_PASS_DECL_ARITHINTRANGEOPTS
#ifdef GEN_PASS_DEF_ARITHINTRANGEOPTS

namespace impl {
  std::unique_ptr<::mlir::Pass> createArithIntRangeOpts();
} // namespace impl
namespace impl {

template <typename DerivedT>
class ArithIntRangeOptsBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithIntRangeOptsBase;

  ArithIntRangeOptsBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithIntRangeOptsBase(const ArithIntRangeOptsBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("int-range-optimizations");
  }
  ::llvm::StringRef getArgument() const override { return "int-range-optimizations"; }

  ::llvm::StringRef getDescription() const override { return "Do optimizations based on integer range analysis"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithIntRangeOpts");
  }
  ::llvm::StringRef getName() const override { return "ArithIntRangeOpts"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithIntRangeOptsBase<DerivedT>)

protected:
private:

  friend std::unique_ptr<::mlir::Pass> createArithIntRangeOpts() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl

std::unique_ptr<::mlir::Pass> createArithIntRangeOpts() {
  return impl::createArithIntRangeOpts();
}
#undef GEN_PASS_DEF_ARITHINTRANGEOPTS
#endif // GEN_PASS_DEF_ARITHINTRANGEOPTS

//===----------------------------------------------------------------------===//
// ArithUnsignedWhenEquivalent
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_ARITHUNSIGNEDWHENEQUIVALENT
#undef GEN_PASS_DECL_ARITHUNSIGNEDWHENEQUIVALENT
#endif // GEN_PASS_DECL_ARITHUNSIGNEDWHENEQUIVALENT
#ifdef GEN_PASS_DEF_ARITHUNSIGNEDWHENEQUIVALENT
namespace impl {

template <typename DerivedT>
class ArithUnsignedWhenEquivalentBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithUnsignedWhenEquivalentBase;

  ArithUnsignedWhenEquivalentBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithUnsignedWhenEquivalentBase(const ArithUnsignedWhenEquivalentBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-unsigned-when-equivalent");
  }
  ::llvm::StringRef getArgument() const override { return "arith-unsigned-when-equivalent"; }

  ::llvm::StringRef getDescription() const override { return "Replace signed ops with unsigned ones where they are proven equivalent"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithUnsignedWhenEquivalent");
  }
  ::llvm::StringRef getName() const override { return "ArithUnsignedWhenEquivalent"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithUnsignedWhenEquivalentBase<DerivedT>)

protected:
private:
};
} // namespace impl
#undef GEN_PASS_DEF_ARITHUNSIGNEDWHENEQUIVALENT
#endif // GEN_PASS_DEF_ARITHUNSIGNEDWHENEQUIVALENT
#ifdef GEN_PASS_REGISTRATION

//===----------------------------------------------------------------------===//
// ArithBufferize Registration
//===----------------------------------------------------------------------===//

inline void registerArithBufferize() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return mlir::arith::createArithBufferizePass();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerArithBufferizePass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return mlir::arith::createArithBufferizePass();
  });
}

//===----------------------------------------------------------------------===//
// ArithEmulateWideInt Registration
//===----------------------------------------------------------------------===//

inline void registerArithEmulateWideInt() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createArithEmulateWideInt();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerArithEmulateWideIntPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createArithEmulateWideInt();
  });
}

//===----------------------------------------------------------------------===//
// ArithExpandOps Registration
//===----------------------------------------------------------------------===//

inline void registerArithExpandOps() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return mlir::arith::createArithExpandOpsPass();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerArithExpandOpsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return mlir::arith::createArithExpandOpsPass();
  });
}

//===----------------------------------------------------------------------===//
// ArithIntRangeOpts Registration
//===----------------------------------------------------------------------===//

inline void registerArithIntRangeOpts() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createArithIntRangeOpts();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerArithIntRangeOptsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createArithIntRangeOpts();
  });
}

//===----------------------------------------------------------------------===//
// ArithUnsignedWhenEquivalent Registration
//===----------------------------------------------------------------------===//

inline void registerArithUnsignedWhenEquivalent() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return mlir::arith::createArithUnsignedWhenEquivalentPass();
  });
}

// Old registration code, kept for temporary backwards compatibility.
inline void registerArithUnsignedWhenEquivalentPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return mlir::arith::createArithUnsignedWhenEquivalentPass();
  });
}

//===----------------------------------------------------------------------===//
// Arith Registration
//===----------------------------------------------------------------------===//

inline void registerArithPasses() {
  registerArithBufferize();
  registerArithEmulateWideInt();
  registerArithExpandOps();
  registerArithIntRangeOpts();
  registerArithUnsignedWhenEquivalent();
}
#undef GEN_PASS_REGISTRATION
#endif // GEN_PASS_REGISTRATION
// Deprecated. Please use the new per-pass macros.
#ifdef GEN_PASS_CLASSES

template <typename DerivedT>
class ArithBufferizeBase : public ::mlir::OperationPass<ModuleOp> {
public:
  using Base = ArithBufferizeBase;

  ArithBufferizeBase() : ::mlir::OperationPass<ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ArithBufferizeBase(const ArithBufferizeBase &other) : ::mlir::OperationPass<ModuleOp>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-bufferize");
  }
  ::llvm::StringRef getArgument() const override { return "arith-bufferize"; }

  ::llvm::StringRef getDescription() const override { return "Bufferize Arith dialect ops."; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithBufferize");
  }
  ::llvm::StringRef getName() const override { return "ArithBufferize"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithBufferizeBase<DerivedT>)

protected:
  ::mlir::Pass::Option<unsigned> alignment{*this, "alignment", ::llvm::cl::desc("Create global memrefs with a specified alignment"), ::llvm::cl::init(0)};
};

template <typename DerivedT>
class ArithEmulateWideIntBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithEmulateWideIntBase;

  ArithEmulateWideIntBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithEmulateWideIntBase(const ArithEmulateWideIntBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-emulate-wide-int");
  }
  ::llvm::StringRef getArgument() const override { return "arith-emulate-wide-int"; }

  ::llvm::StringRef getDescription() const override { return "Emulate 2*N-bit integer operations using N-bit operations"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithEmulateWideInt");
  }
  ::llvm::StringRef getName() const override { return "ArithEmulateWideInt"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  registry.insert<vector::VectorDialect>();

  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithEmulateWideIntBase<DerivedT>)

protected:
  ::mlir::Pass::Option<unsigned> widestIntSupported{*this, "widest-int-supported", ::llvm::cl::desc("Widest integer type supported by the target"), ::llvm::cl::init(32)};
};

template <typename DerivedT>
class ArithExpandOpsBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithExpandOpsBase;

  ArithExpandOpsBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithExpandOpsBase(const ArithExpandOpsBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-expand");
  }
  ::llvm::StringRef getArgument() const override { return "arith-expand"; }

  ::llvm::StringRef getDescription() const override { return "Legalize Arith ops to be convertible to LLVM."; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithExpandOps");
  }
  ::llvm::StringRef getName() const override { return "ArithExpandOps"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithExpandOpsBase<DerivedT>)

protected:
};

template <typename DerivedT>
class ArithIntRangeOptsBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithIntRangeOptsBase;

  ArithIntRangeOptsBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithIntRangeOptsBase(const ArithIntRangeOptsBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("int-range-optimizations");
  }
  ::llvm::StringRef getArgument() const override { return "int-range-optimizations"; }

  ::llvm::StringRef getDescription() const override { return "Do optimizations based on integer range analysis"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithIntRangeOpts");
  }
  ::llvm::StringRef getName() const override { return "ArithIntRangeOpts"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithIntRangeOptsBase<DerivedT>)

protected:
};

template <typename DerivedT>
class ArithUnsignedWhenEquivalentBase : public ::mlir::OperationPass<> {
public:
  using Base = ArithUnsignedWhenEquivalentBase;

  ArithUnsignedWhenEquivalentBase() : ::mlir::OperationPass<>(::mlir::TypeID::get<DerivedT>()) {}
  ArithUnsignedWhenEquivalentBase(const ArithUnsignedWhenEquivalentBase &other) : ::mlir::OperationPass<>(other) {}

  /// Returns the command-line argument attached to this pass.
  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("arith-unsigned-when-equivalent");
  }
  ::llvm::StringRef getArgument() const override { return "arith-unsigned-when-equivalent"; }

  ::llvm::StringRef getDescription() const override { return "Replace signed ops with unsigned ones where they are proven equivalent"; }

  /// Returns the derived pass name.
  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ArithUnsignedWhenEquivalent");
  }
  ::llvm::StringRef getName() const override { return "ArithUnsignedWhenEquivalent"; }

  /// Support isa/dyn_cast functionality for the derived pass class.
  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  /// A clone method to create a copy of this pass.
  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  /// Return the dialect that must be loaded in the context before this pass.
  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    
  }

  /// Explicitly declare the TypeID for this class. We declare an explicit private
  /// instantiation because Pass classes should only be visible by the current
  /// library.
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArithUnsignedWhenEquivalentBase<DerivedT>)

protected:
};
#undef GEN_PASS_CLASSES
#endif // GEN_PASS_CLASSES
