LLZKTransformationPasses.h.inc

Go to the documentation of this file.

/* Autogenerated by mlir-tblgen; don't manually edit */
 
#ifdef GEN_PASS_DECL
// Generate declarations for all passes.
#define GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
#define GEN_PASS_DECL_ENFORCENOMEMBEROVERWRITEPASS
#define GEN_PASS_DECL_FUSEPRODUCTLOOPSPASS
#define GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
#define GEN_PASS_DECL_POLYLOWERINGPASS
#define GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
#define GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
#define GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
#define GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
#define GEN_PASS_DECL_WHILETOFORPASS
#undef GEN_PASS_DECL
#endif // GEN_PASS_DECL
 
//===----------------------------------------------------------------------===//
// ComputeConstrainToProductPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
struct ComputeConstrainToProductPassOptions {
  std::string rootStruct = "Main";
};
std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass();
std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options);
#undef GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
#endif // GEN_PASS_DECL_COMPUTECONSTRAINTOPRODUCTPASS
#ifdef GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass();
} // namespace impl
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options);
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class ComputeConstrainToProductPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = ComputeConstrainToProductPassBase;
 
  ComputeConstrainToProductPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ComputeConstrainToProductPassBase(const ComputeConstrainToProductPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  ComputeConstrainToProductPassBase& operator=(const ComputeConstrainToProductPassBase &) = delete;
  ComputeConstrainToProductPassBase(ComputeConstrainToProductPassBase &&) = delete;
  ComputeConstrainToProductPassBase& operator=(ComputeConstrainToProductPassBase &&) = delete;
  ~ComputeConstrainToProductPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-compute-constrain-to-product");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-compute-constrain-to-product"; }
 
  ::llvm::StringRef getDescription() const override { return "Replace separate @compute and @constrain functions in a struct with a single @product function"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ComputeConstrainToProductPass");
  }
  ::llvm::StringRef getName() const override { return "ComputeConstrainToProductPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ComputeConstrainToProductPassBase<DerivedT>)
 
  ComputeConstrainToProductPassBase(ComputeConstrainToProductPassOptions options) : ComputeConstrainToProductPassBase() {
    rootStruct = std::move(options.rootStruct);
  }
protected:
  ::mlir::Pass::Option<std::string> rootStruct{*this, "root-struct", ::llvm::cl::desc("Root struct at which to start alignment (default to `@Main`)"), ::llvm::cl::init("Main")};
private:
 
  friend std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass() {
    return std::make_unique<DerivedT>();
  }
 
  friend std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass() {
  return impl::createComputeConstrainToProductPass();
}
 
std::unique_ptr<::mlir::Pass> createComputeConstrainToProductPass(ComputeConstrainToProductPassOptions options) {
  return impl::createComputeConstrainToProductPass(std::move(options));
}
#undef GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
#endif // GEN_PASS_DEF_COMPUTECONSTRAINTOPRODUCTPASS
 
//===----------------------------------------------------------------------===//
// EnforceNoMemberOverwritePass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_ENFORCENOMEMBEROVERWRITEPASS
std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass();
#undef GEN_PASS_DECL_ENFORCENOMEMBEROVERWRITEPASS
#endif // GEN_PASS_DECL_ENFORCENOMEMBEROVERWRITEPASS
#ifdef GEN_PASS_DEF_ENFORCENOMEMBEROVERWRITEPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class EnforceNoMemberOverwritePassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = EnforceNoMemberOverwritePassBase;
 
  EnforceNoMemberOverwritePassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  EnforceNoMemberOverwritePassBase(const EnforceNoMemberOverwritePassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  EnforceNoMemberOverwritePassBase& operator=(const EnforceNoMemberOverwritePassBase &) = delete;
  EnforceNoMemberOverwritePassBase(EnforceNoMemberOverwritePassBase &&) = delete;
  EnforceNoMemberOverwritePassBase& operator=(EnforceNoMemberOverwritePassBase &&) = delete;
  ~EnforceNoMemberOverwritePassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-enforce-no-overwrite");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-enforce-no-overwrite"; }
 
  ::llvm::StringRef getDescription() const override { return "Checks that every struct member is written exactly once"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("EnforceNoMemberOverwritePass");
  }
  ::llvm::StringRef getName() const override { return "EnforceNoMemberOverwritePass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(EnforceNoMemberOverwritePassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createEnforceNoMemberOverwritePass() {
  return impl::createEnforceNoMemberOverwritePass();
}
#undef GEN_PASS_DEF_ENFORCENOMEMBEROVERWRITEPASS
#endif // GEN_PASS_DEF_ENFORCENOMEMBEROVERWRITEPASS
 
//===----------------------------------------------------------------------===//
// FuseProductLoopsPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_FUSEPRODUCTLOOPSPASS
std::unique_ptr<::mlir::Pass> createFuseProductLoopsPass();
#undef GEN_PASS_DECL_FUSEPRODUCTLOOPSPASS
#endif // GEN_PASS_DECL_FUSEPRODUCTLOOPSPASS
#ifdef GEN_PASS_DEF_FUSEPRODUCTLOOPSPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createFuseProductLoopsPass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class FuseProductLoopsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = FuseProductLoopsPassBase;
 
  FuseProductLoopsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  FuseProductLoopsPassBase(const FuseProductLoopsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  FuseProductLoopsPassBase& operator=(const FuseProductLoopsPassBase &) = delete;
  FuseProductLoopsPassBase(FuseProductLoopsPassBase &&) = delete;
  FuseProductLoopsPassBase& operator=(FuseProductLoopsPassBase &&) = delete;
  ~FuseProductLoopsPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-fuse-product-loops");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-fuse-product-loops"; }
 
  ::llvm::StringRef getDescription() const override { return "Fuse matching witness/constraint loops in a @product function"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("FuseProductLoopsPass");
  }
  ::llvm::StringRef getName() const override { return "FuseProductLoopsPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FuseProductLoopsPassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createFuseProductLoopsPass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createFuseProductLoopsPass() {
  return impl::createFuseProductLoopsPass();
}
#undef GEN_PASS_DEF_FUSEPRODUCTLOOPSPASS
#endif // GEN_PASS_DEF_FUSEPRODUCTLOOPSPASS
 
//===----------------------------------------------------------------------===//
// InlineFreeFunctionsPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass();
#undef GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
#endif // GEN_PASS_DECL_INLINEFREEFUNCTIONSPASS
#ifdef GEN_PASS_DEF_INLINEFREEFUNCTIONSPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class InlineFreeFunctionsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = InlineFreeFunctionsPassBase;
 
  InlineFreeFunctionsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  InlineFreeFunctionsPassBase(const InlineFreeFunctionsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  InlineFreeFunctionsPassBase& operator=(const InlineFreeFunctionsPassBase &) = delete;
  InlineFreeFunctionsPassBase(InlineFreeFunctionsPassBase &&) = delete;
  InlineFreeFunctionsPassBase& operator=(InlineFreeFunctionsPassBase &&) = delete;
  ~InlineFreeFunctionsPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-inline-free-functions");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-inline-free-functions"; }
 
  ::llvm::StringRef getDescription() const override { return "Inline calls to free functions"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("InlineFreeFunctionsPass");
  }
  ::llvm::StringRef getName() const override { return "InlineFreeFunctionsPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineFreeFunctionsPassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createInlineFreeFunctionsPass() {
  return impl::createInlineFreeFunctionsPass();
}
#undef GEN_PASS_DEF_INLINEFREEFUNCTIONSPASS
#endif // GEN_PASS_DEF_INLINEFREEFUNCTIONSPASS
 
//===----------------------------------------------------------------------===//
// PolyLoweringPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_POLYLOWERINGPASS
struct PolyLoweringPassOptions {
  unsigned maxDegree = 2;
};
std::unique_ptr<::mlir::Pass> createPolyLoweringPass();
std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options);
#undef GEN_PASS_DECL_POLYLOWERINGPASS
#endif // GEN_PASS_DECL_POLYLOWERINGPASS
#ifdef GEN_PASS_DEF_POLYLOWERINGPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createPolyLoweringPass();
} // namespace impl
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options);
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = PolyLoweringPassBase;
 
  PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  PolyLoweringPassBase& operator=(const PolyLoweringPassBase &) = delete;
  PolyLoweringPassBase(PolyLoweringPassBase &&) = delete;
  PolyLoweringPassBase& operator=(PolyLoweringPassBase &&) = delete;
  ~PolyLoweringPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-poly-lowering-pass");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
 
  ::llvm::StringRef getDescription() const override { return "Lower the degree of all polynomial equations to a specified maximum"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("PolyLoweringPass");
  }
  ::llvm::StringRef getName() const override { return "PolyLoweringPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
 
  PolyLoweringPassBase(PolyLoweringPassOptions options) : PolyLoweringPassBase() {
    maxDegree = std::move(options.maxDegree);
  }
protected:
  ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
private:
 
  friend std::unique_ptr<::mlir::Pass> createPolyLoweringPass() {
    return std::make_unique<DerivedT>();
  }
 
  friend std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createPolyLoweringPass() {
  return impl::createPolyLoweringPass();
}
 
std::unique_ptr<::mlir::Pass> createPolyLoweringPass(PolyLoweringPassOptions options) {
  return impl::createPolyLoweringPass(std::move(options));
}
#undef GEN_PASS_DEF_POLYLOWERINGPASS
#endif // GEN_PASS_DEF_POLYLOWERINGPASS
 
//===----------------------------------------------------------------------===//
// RedundantOperationEliminationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass();
#undef GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
#endif // GEN_PASS_DECL_REDUNDANTOPERATIONELIMINATIONPASS
#ifdef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantOperationEliminationPassBase;
 
  RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  RedundantOperationEliminationPassBase& operator=(const RedundantOperationEliminationPassBase &) = delete;
  RedundantOperationEliminationPassBase(RedundantOperationEliminationPassBase &&) = delete;
  RedundantOperationEliminationPassBase& operator=(RedundantOperationEliminationPassBase &&) = delete;
  ~RedundantOperationEliminationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-op-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("RedundantOperationEliminationPass");
  }
  ::llvm::StringRef getName() const override { return "RedundantOperationEliminationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createRedundantOperationEliminationPass() {
  return impl::createRedundantOperationEliminationPass();
}
#undef GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
#endif // GEN_PASS_DEF_REDUNDANTOPERATIONELIMINATIONPASS
 
//===----------------------------------------------------------------------===//
// RedundantReadAndWriteEliminationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass();
#undef GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
#endif // GEN_PASS_DECL_REDUNDANTREADANDWRITEELIMINATIONPASS
#ifdef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantReadAndWriteEliminationPassBase;
 
  RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  RedundantReadAndWriteEliminationPassBase& operator=(const RedundantReadAndWriteEliminationPassBase &) = delete;
  RedundantReadAndWriteEliminationPassBase(RedundantReadAndWriteEliminationPassBase &&) = delete;
  RedundantReadAndWriteEliminationPassBase& operator=(RedundantReadAndWriteEliminationPassBase &&) = delete;
  ~RedundantReadAndWriteEliminationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("RedundantReadAndWriteEliminationPass");
  }
  ::llvm::StringRef getName() const override { return "RedundantReadAndWriteEliminationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createRedundantReadAndWriteEliminationPass() {
  return impl::createRedundantReadAndWriteEliminationPass();
}
#undef GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
#endif // GEN_PASS_DEF_REDUNDANTREADANDWRITEELIMINATIONPASS
 
//===----------------------------------------------------------------------===//
// RemoveUnusedDiscardableAllocationsPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
struct RemoveUnusedDiscardableAllocationsPassOptions {
  std::string allocatorOpName = "";
};
std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass();
std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options);
#undef GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
#endif // GEN_PASS_DECL_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
#ifdef GEN_PASS_DEF_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass();
} // namespace impl
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options);
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class RemoveUnusedDiscardableAllocationsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RemoveUnusedDiscardableAllocationsPassBase;
 
  RemoveUnusedDiscardableAllocationsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RemoveUnusedDiscardableAllocationsPassBase(const RemoveUnusedDiscardableAllocationsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  RemoveUnusedDiscardableAllocationsPassBase& operator=(const RemoveUnusedDiscardableAllocationsPassBase &) = delete;
  RemoveUnusedDiscardableAllocationsPassBase(RemoveUnusedDiscardableAllocationsPassBase &&) = delete;
  RemoveUnusedDiscardableAllocationsPassBase& operator=(RemoveUnusedDiscardableAllocationsPassBase &&) = delete;
  ~RemoveUnusedDiscardableAllocationsPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-remove-unused-discardable-allocations");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-remove-unused-discardable-allocations"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove unread discardable allocations and their dead stores"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("RemoveUnusedDiscardableAllocationsPass");
  }
  ::llvm::StringRef getName() const override { return "RemoveUnusedDiscardableAllocationsPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RemoveUnusedDiscardableAllocationsPassBase<DerivedT>)
 
  RemoveUnusedDiscardableAllocationsPassBase(RemoveUnusedDiscardableAllocationsPassOptions options) : RemoveUnusedDiscardableAllocationsPassBase() {
    allocatorOpName = std::move(options.allocatorOpName);
  }
protected:
  ::mlir::Pass::Option<std::string> allocatorOpName{*this, "allocator-op", ::llvm::cl::desc("Operation name of the discardable allocator to remove"), ::llvm::cl::init("")};
private:
 
  friend std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass() {
    return std::make_unique<DerivedT>();
  }
 
  friend std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass() {
  return impl::createRemoveUnusedDiscardableAllocationsPass();
}
 
std::unique_ptr<::mlir::Pass> createRemoveUnusedDiscardableAllocationsPass(RemoveUnusedDiscardableAllocationsPassOptions options) {
  return impl::createRemoveUnusedDiscardableAllocationsPass(std::move(options));
}
#undef GEN_PASS_DEF_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
#endif // GEN_PASS_DEF_REMOVEUNUSEDDISCARDABLEALLOCATIONSPASS
 
//===----------------------------------------------------------------------===//
// UnusedDeclarationEliminationPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
struct UnusedDeclarationEliminationPassOptions {
  bool removeStructs = false;
};
std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass();
std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options);
#undef GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
#endif // GEN_PASS_DECL_UNUSEDDECLARATIONELIMINATIONPASS
#ifdef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass();
} // namespace impl
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options);
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = UnusedDeclarationEliminationPassBase;
 
  UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  UnusedDeclarationEliminationPassBase& operator=(const UnusedDeclarationEliminationPassBase &) = delete;
  UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassBase &&) = delete;
  UnusedDeclarationEliminationPassBase& operator=(UnusedDeclarationEliminationPassBase &&) = delete;
  ~UnusedDeclarationEliminationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-unused-declaration-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove unused member and struct declarations"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("UnusedDeclarationEliminationPass");
  }
  ::llvm::StringRef getName() const override { return "UnusedDeclarationEliminationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
 
  UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassOptions options) : UnusedDeclarationEliminationPassBase() {
    removeStructs = std::move(options.removeStructs);
  }
protected:
  ::mlir::Pass::Option<bool> removeStructs{*this, "remove-structs", ::llvm::cl::desc("Whether to remove unused struct definitions as well. Requires module to declare a Main component, otherwise all components will appear unused."), ::llvm::cl::init(false)};
private:
 
  friend std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass() {
    return std::make_unique<DerivedT>();
  }
 
  friend std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options) {
    return std::make_unique<DerivedT>(std::move(options));
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass() {
  return impl::createUnusedDeclarationEliminationPass();
}
 
std::unique_ptr<::mlir::Pass> createUnusedDeclarationEliminationPass(UnusedDeclarationEliminationPassOptions options) {
  return impl::createUnusedDeclarationEliminationPass(std::move(options));
}
#undef GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
#endif // GEN_PASS_DEF_UNUSEDDECLARATIONELIMINATIONPASS
 
//===----------------------------------------------------------------------===//
// WhileToForPass
//===----------------------------------------------------------------------===//
#ifdef GEN_PASS_DECL_WHILETOFORPASS
std::unique_ptr<::mlir::Pass> createWhileToForPass();
#undef GEN_PASS_DECL_WHILETOFORPASS
#endif // GEN_PASS_DECL_WHILETOFORPASS
#ifdef GEN_PASS_DEF_WHILETOFORPASS
 
namespace impl {
  std::unique_ptr<::mlir::Pass> createWhileToForPass();
} // namespace impl
namespace impl {
 
template <typename DerivedT>
class WhileToForPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = WhileToForPassBase;
 
  WhileToForPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  WhileToForPassBase(const WhileToForPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  WhileToForPassBase& operator=(const WhileToForPassBase &) = delete;
  WhileToForPassBase(WhileToForPassBase &&) = delete;
  WhileToForPassBase& operator=(WhileToForPassBase &&) = delete;
  ~WhileToForPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-while-to-for");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-while-to-for"; }
 
  ::llvm::StringRef getDescription() const override { return "Converts scf.while loops to equivalent scf.for loops when possible"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("WhileToForPass");
  }
  ::llvm::StringRef getName() const override { return "WhileToForPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(WhileToForPassBase<DerivedT>)
 
protected:
private:
 
  friend std::unique_ptr<::mlir::Pass> createWhileToForPass() {
    return std::make_unique<DerivedT>();
  }
};
} // namespace impl
 
std::unique_ptr<::mlir::Pass> createWhileToForPass() {
  return impl::createWhileToForPass();
}
#undef GEN_PASS_DEF_WHILETOFORPASS
#endif // GEN_PASS_DEF_WHILETOFORPASS
#ifdef GEN_PASS_REGISTRATION
 
//===----------------------------------------------------------------------===//
// ComputeConstrainToProductPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerComputeConstrainToProductPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createComputeConstrainToProductPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerComputeConstrainToProductPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createComputeConstrainToProductPass();
  });
}
 
//===----------------------------------------------------------------------===//
// EnforceNoMemberOverwritePass Registration
//===----------------------------------------------------------------------===//
 
inline void registerEnforceNoMemberOverwritePass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createEnforceNoMemberOverwritePass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerEnforceNoMemberOverwritePassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createEnforceNoMemberOverwritePass();
  });
}
 
//===----------------------------------------------------------------------===//
// FuseProductLoopsPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerFuseProductLoopsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createFuseProductLoopsPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerFuseProductLoopsPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createFuseProductLoopsPass();
  });
}
 
//===----------------------------------------------------------------------===//
// InlineFreeFunctionsPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerInlineFreeFunctionsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineFreeFunctionsPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerInlineFreeFunctionsPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createInlineFreeFunctionsPass();
  });
}
 
//===----------------------------------------------------------------------===//
// PolyLoweringPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerPolyLoweringPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createPolyLoweringPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerPolyLoweringPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createPolyLoweringPass();
  });
}
 
//===----------------------------------------------------------------------===//
// RedundantOperationEliminationPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerRedundantOperationEliminationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createRedundantOperationEliminationPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerRedundantOperationEliminationPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createRedundantOperationEliminationPass();
  });
}
 
//===----------------------------------------------------------------------===//
// RedundantReadAndWriteEliminationPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerRedundantReadAndWriteEliminationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createRedundantReadAndWriteEliminationPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerRedundantReadAndWriteEliminationPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createRedundantReadAndWriteEliminationPass();
  });
}
 
//===----------------------------------------------------------------------===//
// RemoveUnusedDiscardableAllocationsPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerRemoveUnusedDiscardableAllocationsPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createRemoveUnusedDiscardableAllocationsPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerRemoveUnusedDiscardableAllocationsPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createRemoveUnusedDiscardableAllocationsPass();
  });
}
 
//===----------------------------------------------------------------------===//
// UnusedDeclarationEliminationPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerUnusedDeclarationEliminationPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createUnusedDeclarationEliminationPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerUnusedDeclarationEliminationPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createUnusedDeclarationEliminationPass();
  });
}
 
//===----------------------------------------------------------------------===//
// WhileToForPass Registration
//===----------------------------------------------------------------------===//
 
inline void registerWhileToForPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createWhileToForPass();
  });
}
 
// Old registration code, kept for temporary backwards compatibility.
inline void registerWhileToForPassPass() {
  ::mlir::registerPass([]() -> std::unique_ptr<::mlir::Pass> {
    return createWhileToForPass();
  });
}
 
//===----------------------------------------------------------------------===//
// Transformation Registration
//===----------------------------------------------------------------------===//
 
inline void registerTransformationPasses() {
  registerComputeConstrainToProductPass();
  registerEnforceNoMemberOverwritePass();
  registerFuseProductLoopsPass();
  registerInlineFreeFunctionsPass();
  registerPolyLoweringPass();
  registerRedundantOperationEliminationPass();
  registerRedundantReadAndWriteEliminationPass();
  registerRemoveUnusedDiscardableAllocationsPass();
  registerUnusedDeclarationEliminationPass();
  registerWhileToForPass();
}
#undef GEN_PASS_REGISTRATION
#endif // GEN_PASS_REGISTRATION
// Deprecated. Please use the new per-pass macros.
#ifdef GEN_PASS_CLASSES
 
template <typename DerivedT>
class ComputeConstrainToProductPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = ComputeConstrainToProductPassBase;
 
  ComputeConstrainToProductPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  ComputeConstrainToProductPassBase(const ComputeConstrainToProductPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  ComputeConstrainToProductPassBase& operator=(const ComputeConstrainToProductPassBase &) = delete;
  ComputeConstrainToProductPassBase(ComputeConstrainToProductPassBase &&) = delete;
  ComputeConstrainToProductPassBase& operator=(ComputeConstrainToProductPassBase &&) = delete;
  ~ComputeConstrainToProductPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-compute-constrain-to-product");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-compute-constrain-to-product"; }
 
  ::llvm::StringRef getDescription() const override { return "Replace separate @compute and @constrain functions in a struct with a single @product function"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("ComputeConstrainToProductPass");
  }
  ::llvm::StringRef getName() const override { return "ComputeConstrainToProductPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ComputeConstrainToProductPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<std::string> rootStruct{*this, "root-struct", ::llvm::cl::desc("Root struct at which to start alignment (default to `@Main`)"), ::llvm::cl::init("Main")};
};
 
template <typename DerivedT>
class EnforceNoMemberOverwritePassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = EnforceNoMemberOverwritePassBase;
 
  EnforceNoMemberOverwritePassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  EnforceNoMemberOverwritePassBase(const EnforceNoMemberOverwritePassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  EnforceNoMemberOverwritePassBase& operator=(const EnforceNoMemberOverwritePassBase &) = delete;
  EnforceNoMemberOverwritePassBase(EnforceNoMemberOverwritePassBase &&) = delete;
  EnforceNoMemberOverwritePassBase& operator=(EnforceNoMemberOverwritePassBase &&) = delete;
  ~EnforceNoMemberOverwritePassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-enforce-no-overwrite");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-enforce-no-overwrite"; }
 
  ::llvm::StringRef getDescription() const override { return "Checks that every struct member is written exactly once"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("EnforceNoMemberOverwritePass");
  }
  ::llvm::StringRef getName() const override { return "EnforceNoMemberOverwritePass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(EnforceNoMemberOverwritePassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class FuseProductLoopsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = FuseProductLoopsPassBase;
 
  FuseProductLoopsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  FuseProductLoopsPassBase(const FuseProductLoopsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  FuseProductLoopsPassBase& operator=(const FuseProductLoopsPassBase &) = delete;
  FuseProductLoopsPassBase(FuseProductLoopsPassBase &&) = delete;
  FuseProductLoopsPassBase& operator=(FuseProductLoopsPassBase &&) = delete;
  ~FuseProductLoopsPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-fuse-product-loops");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-fuse-product-loops"; }
 
  ::llvm::StringRef getDescription() const override { return "Fuse matching witness/constraint loops in a @product function"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("FuseProductLoopsPass");
  }
  ::llvm::StringRef getName() const override { return "FuseProductLoopsPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(FuseProductLoopsPassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class InlineFreeFunctionsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = InlineFreeFunctionsPassBase;
 
  InlineFreeFunctionsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  InlineFreeFunctionsPassBase(const InlineFreeFunctionsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  InlineFreeFunctionsPassBase& operator=(const InlineFreeFunctionsPassBase &) = delete;
  InlineFreeFunctionsPassBase(InlineFreeFunctionsPassBase &&) = delete;
  InlineFreeFunctionsPassBase& operator=(InlineFreeFunctionsPassBase &&) = delete;
  ~InlineFreeFunctionsPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-inline-free-functions");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-inline-free-functions"; }
 
  ::llvm::StringRef getDescription() const override { return "Inline calls to free functions"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("InlineFreeFunctionsPass");
  }
  ::llvm::StringRef getName() const override { return "InlineFreeFunctionsPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(InlineFreeFunctionsPassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class PolyLoweringPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = PolyLoweringPassBase;
 
  PolyLoweringPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  PolyLoweringPassBase(const PolyLoweringPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  PolyLoweringPassBase& operator=(const PolyLoweringPassBase &) = delete;
  PolyLoweringPassBase(PolyLoweringPassBase &&) = delete;
  PolyLoweringPassBase& operator=(PolyLoweringPassBase &&) = delete;
  ~PolyLoweringPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-poly-lowering-pass");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-poly-lowering-pass"; }
 
  ::llvm::StringRef getDescription() const override { return "Lower the degree of all polynomial equations to a specified maximum"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("PolyLoweringPass");
  }
  ::llvm::StringRef getName() const override { return "PolyLoweringPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(PolyLoweringPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<unsigned> maxDegree{*this, "max-degree", ::llvm::cl::desc("Maximum degree of constraint polynomials (default 2, minimum 2)"), ::llvm::cl::init(2)};
};
 
template <typename DerivedT>
class RedundantOperationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantOperationEliminationPassBase;
 
  RedundantOperationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantOperationEliminationPassBase(const RedundantOperationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  RedundantOperationEliminationPassBase& operator=(const RedundantOperationEliminationPassBase &) = delete;
  RedundantOperationEliminationPassBase(RedundantOperationEliminationPassBase &&) = delete;
  RedundantOperationEliminationPassBase& operator=(RedundantOperationEliminationPassBase &&) = delete;
  ~RedundantOperationEliminationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-op-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-op-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant operations"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("RedundantOperationEliminationPass");
  }
  ::llvm::StringRef getName() const override { return "RedundantOperationEliminationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantOperationEliminationPassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class RedundantReadAndWriteEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RedundantReadAndWriteEliminationPassBase;
 
  RedundantReadAndWriteEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RedundantReadAndWriteEliminationPassBase(const RedundantReadAndWriteEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  RedundantReadAndWriteEliminationPassBase& operator=(const RedundantReadAndWriteEliminationPassBase &) = delete;
  RedundantReadAndWriteEliminationPassBase(RedundantReadAndWriteEliminationPassBase &&) = delete;
  RedundantReadAndWriteEliminationPassBase& operator=(RedundantReadAndWriteEliminationPassBase &&) = delete;
  ~RedundantReadAndWriteEliminationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-duplicate-read-write-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-duplicate-read-write-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove redundant reads and writes"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("RedundantReadAndWriteEliminationPass");
  }
  ::llvm::StringRef getName() const override { return "RedundantReadAndWriteEliminationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RedundantReadAndWriteEliminationPassBase<DerivedT>)
 
protected:
};
 
template <typename DerivedT>
class RemoveUnusedDiscardableAllocationsPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = RemoveUnusedDiscardableAllocationsPassBase;
 
  RemoveUnusedDiscardableAllocationsPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  RemoveUnusedDiscardableAllocationsPassBase(const RemoveUnusedDiscardableAllocationsPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  RemoveUnusedDiscardableAllocationsPassBase& operator=(const RemoveUnusedDiscardableAllocationsPassBase &) = delete;
  RemoveUnusedDiscardableAllocationsPassBase(RemoveUnusedDiscardableAllocationsPassBase &&) = delete;
  RemoveUnusedDiscardableAllocationsPassBase& operator=(RemoveUnusedDiscardableAllocationsPassBase &&) = delete;
  ~RemoveUnusedDiscardableAllocationsPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-remove-unused-discardable-allocations");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-remove-unused-discardable-allocations"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove unread discardable allocations and their dead stores"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("RemoveUnusedDiscardableAllocationsPass");
  }
  ::llvm::StringRef getName() const override { return "RemoveUnusedDiscardableAllocationsPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(RemoveUnusedDiscardableAllocationsPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<std::string> allocatorOpName{*this, "allocator-op", ::llvm::cl::desc("Operation name of the discardable allocator to remove"), ::llvm::cl::init("")};
};
 
template <typename DerivedT>
class UnusedDeclarationEliminationPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = UnusedDeclarationEliminationPassBase;
 
  UnusedDeclarationEliminationPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  UnusedDeclarationEliminationPassBase(const UnusedDeclarationEliminationPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  UnusedDeclarationEliminationPassBase& operator=(const UnusedDeclarationEliminationPassBase &) = delete;
  UnusedDeclarationEliminationPassBase(UnusedDeclarationEliminationPassBase &&) = delete;
  UnusedDeclarationEliminationPassBase& operator=(UnusedDeclarationEliminationPassBase &&) = delete;
  ~UnusedDeclarationEliminationPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-unused-declaration-elim");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-unused-declaration-elim"; }
 
  ::llvm::StringRef getDescription() const override { return "Remove unused member and struct declarations"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("UnusedDeclarationEliminationPass");
  }
  ::llvm::StringRef getName() const override { return "UnusedDeclarationEliminationPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(UnusedDeclarationEliminationPassBase<DerivedT>)
 
protected:
  ::mlir::Pass::Option<bool> removeStructs{*this, "remove-structs", ::llvm::cl::desc("Whether to remove unused struct definitions as well. Requires module to declare a Main component, otherwise all components will appear unused."), ::llvm::cl::init(false)};
};
 
template <typename DerivedT>
class WhileToForPassBase : public ::mlir::OperationPass<::mlir::ModuleOp> {
public:
  using Base = WhileToForPassBase;
 
  WhileToForPassBase() : ::mlir::OperationPass<::mlir::ModuleOp>(::mlir::TypeID::get<DerivedT>()) {}
  WhileToForPassBase(const WhileToForPassBase &other) : ::mlir::OperationPass<::mlir::ModuleOp>(other) {}
  WhileToForPassBase& operator=(const WhileToForPassBase &) = delete;
  WhileToForPassBase(WhileToForPassBase &&) = delete;
  WhileToForPassBase& operator=(WhileToForPassBase &&) = delete;
  ~WhileToForPassBase() = default;

  static constexpr ::llvm::StringLiteral getArgumentName() {
    return ::llvm::StringLiteral("llzk-while-to-for");
  }
  ::llvm::StringRef getArgument() const override { return "llzk-while-to-for"; }
 
  ::llvm::StringRef getDescription() const override { return "Converts scf.while loops to equivalent scf.for loops when possible"; }

  static constexpr ::llvm::StringLiteral getPassName() {
    return ::llvm::StringLiteral("WhileToForPass");
  }
  ::llvm::StringRef getName() const override { return "WhileToForPass"; }

  static bool classof(const ::mlir::Pass *pass) {
    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
  }

  std::unique_ptr<::mlir::Pass> clonePass() const override {
    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
  }

  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
    registry.insert<llzk::LLZKDialect>();
    registry.insert<llzk::boolean::BoolDialect>();
    registry.insert<llzk::array::ArrayDialect>();
    registry.insert<llzk::component::StructDialect>();
    registry.insert<llzk::constrain::ConstrainDialect>();
    registry.insert<llzk::felt::FeltDialect>();
    registry.insert<llzk::global::GlobalDialect>();
    registry.insert<llzk::include::IncludeDialect>();
    registry.insert<llzk::function::FunctionDialect>();
    registry.insert<llzk::string::StringDialect>();
    registry.insert<llzk::polymorphic::PolymorphicDialect>();
    registry.insert<mlir::arith::ArithDialect>();
    registry.insert<mlir::scf::SCFDialect>();
  }

  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(WhileToForPassBase<DerivedT>)
 
protected:
};
#undef GEN_PASS_CLASSES
#endif // GEN_PASS_CLASSES