Ops.capi.cpp.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op C API Definitions                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: Ops.td                                                               *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
 
#include <limits>
 
using namespace mlir;
using namespace llvm;
 
MlirOperation llzkVerif_AssumeDetOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue hint) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.det.assume"), location);
  mlirOperationStateAddOperands(&state, 1, &hint);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_AssumeDetOp(MlirOperation inp) {
  return llvm::isa<AssumeDetOp>(unwrap(inp));
}
 
MlirValue llzkVerif_AssumeDetOpGetHint(MlirOperation op) {
  auto range = llvm::cast<AssumeDetOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_AssumeDetOpSetHint(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<AssumeDetOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_ContractEndOpBuild(MlirOpBuilder builder, MlirLocation location) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.contract_end"), location);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_ContractEndOp(MlirOperation inp) {
  return llvm::isa<ContractEndOp>(unwrap(inp));
}
 
bool llzkOperationIsA_Verif_ContractOp(MlirOperation inp) {
  return llvm::isa<ContractOp>(unwrap(inp));
}
 
MlirAttribute llzkVerif_ContractOpGetSymName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"));
}
 
void llzkVerif_ContractOpSetSymName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("sym_name"), attr);
}
 
MlirAttribute llzkVerif_ContractOpGetTarget(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("target"));
}
 
void llzkVerif_ContractOpSetTarget(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("target"), attr);
}
 
MlirAttribute llzkVerif_ContractOpGetFunctionType(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("function_type"));
}
 
void llzkVerif_ContractOpSetFunctionType(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("function_type"), attr);
}
 
MlirAttribute llzkVerif_ContractOpGetArgAttrs(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("arg_attrs"));
}
 
void llzkVerif_ContractOpSetArgAttrs(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("arg_attrs"), attr);
}
 
MlirRegion llzkVerif_ContractOpGetBody(MlirOperation op) {
  return mlirOperationGetRegion(op, 0);
}
 
bool llzkVerif_ContractOpIsDeclaration(MlirOperation inp) {
  return llvm::cast<ContractOp>(unwrap(inp)).isDeclaration();
}
 
bool llzkVerif_ContractOpHasArgPublicAttr(MlirOperation inp, unsigned index) {
  return llvm::cast<ContractOp>(unwrap(inp)).hasArgPublicAttr(index);
}
 
bool llzkVerif_ContractOpHasFuncTarget(MlirOperation inp) {
  return llvm::cast<ContractOp>(unwrap(inp)).hasFuncTarget();
}
 
bool llzkVerif_ContractOpHasStructTarget(MlirOperation inp) {
  return llvm::cast<ContractOp>(unwrap(inp)).hasStructTarget();
}
 
MlirRegion llzkVerif_ContractOpGetCallableRegion(MlirOperation inp) {
  return wrap(llvm::cast<ContractOp>(unwrap(inp)).getCallableRegion());
}
 
bool llzkVerif_ContractOpHasArgName(MlirOperation inp, unsigned index) {
  return llvm::cast<ContractOp>(unwrap(inp)).hasArgName(index);
}
 
MlirAttribute llzkVerif_ContractOpGetFullyQualifiedName(MlirOperation inp, bool requireParent) {
  return wrap(llvm::cast<ContractOp>(unwrap(inp)).getFullyQualifiedName(requireParent));
}
 
MlirOperation llzkVerif_DecreasesOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.decreases"), location);
  mlirOperationStateAddOperands(&state, 1, &value);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_DecreasesOp(MlirOperation inp) {
  return llvm::isa<DecreasesOp>(unwrap(inp));
}
 
MlirValue llzkVerif_DecreasesOpGetValue(MlirOperation op) {
  auto range = llvm::cast<DecreasesOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_DecreasesOpSetValue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<DecreasesOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_EnsureComputeOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.ensure_compute"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_EnsureComputeOp(MlirOperation inp) {
  return llvm::isa<EnsureComputeOp>(unwrap(inp));
}
 
MlirValue llzkVerif_EnsureComputeOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<EnsureComputeOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_EnsureComputeOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<EnsureComputeOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_EnsureConstrainOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.ensure_constrain"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_EnsureConstrainOp(MlirOperation inp) {
  return llvm::isa<EnsureConstrainOp>(unwrap(inp));
}
 
MlirValue llzkVerif_EnsureConstrainOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<EnsureConstrainOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_EnsureConstrainOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<EnsureConstrainOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
bool llzkOperationIsA_Verif_IncludeOp(MlirOperation inp) {
  return llvm::isa<IncludeOp>(unwrap(inp));
}
 
intptr_t llzkVerif_IncludeOpGetArgOperandsCount(MlirOperation op) {
  auto range = llvm::cast<IncludeOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  return range.second;
}
 
MlirValue llzkVerif_IncludeOpGetArgOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<IncludeOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(index >= 0 && index < range.second && "variadic operand index out of range");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first) + index);
}
 
void llzkVerif_IncludeOpSetArgOperands(MlirOperation op, intptr_t count, MlirValue const *values) {
  if (count < 0)
    return;
  ::llvm::SmallVector<::mlir::Value> vals;
  vals.reserve(static_cast<size_t>(count));
  for (intptr_t i = 0; i < count; ++i)
    vals.push_back(unwrap(values[i]));
  ::llvm::cast<IncludeOp>(unwrap(op)).getArgOperandsMutable().assign(vals);
}
 
intptr_t llzkVerif_IncludeOpGetMapOperandsCount(MlirOperation op) {
  auto range = llvm::cast<IncludeOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  return range.second;
}
 
MlirValue llzkVerif_IncludeOpGetMapOperandsAt(MlirOperation op, intptr_t index) {
  auto range = llvm::cast<IncludeOp>(unwrap(op)).getODSOperandIndexAndLength(1);
  assert(index >= 0 && index < range.second && "variadic operand index out of range");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first) + index);
}
 
void llzkVerif_IncludeOpSetMapOperands(MlirOperation op, intptr_t groupCount, MlirValueRange const *groups) {
  if (groupCount < 0)
    return;
 
  ::llvm::SmallVector<::mlir::Value> vals;
  for (intptr_t g = 0; g < groupCount; ++g) {
    assert(groups[g].size >= 0 && "group size must be non-negative");
    for (intptr_t i = 0; i < groups[g].size; ++i) {
      vals.push_back(unwrap(groups[g].values[i]));
    }
  }
  ::llvm::cast<IncludeOp>(unwrap(op)).getMapOperandsMutable().join().assign(vals);
 
  ::llvm::SmallVector<int32_t> newGroupSizes;
  newGroupSizes.reserve(static_cast<size_t>(groupCount));
  for (intptr_t g = 0; g < groupCount; ++g) {
    assert(
        groups[g].size <= static_cast<intptr_t>(std::numeric_limits<int32_t>::max()) &&
        "group size exceeds int32_t range"
    );
    newGroupSizes.push_back(static_cast<int32_t>(groups[g].size));
  }
  MlirContext ctx = mlirOperationGetContext(op);
  assert(
      newGroupSizes.size() <= static_cast<size_t>(std::numeric_limits<intptr_t>::max()) &&
      "group count exceeds intptr_t range"
  );
  mlirOperationSetAttributeByName(
      op, mlirStringRefCreateFromCString("mapOpGroupSizes"),
      mlirDenseI32ArrayGet(ctx, static_cast<intptr_t>(newGroupSizes.size()), newGroupSizes.data())
  );
}
 
MlirAttribute llzkVerif_IncludeOpGetCallee(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("callee"));
}
 
void llzkVerif_IncludeOpSetCallee(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("callee"), attr);
}
 
MlirAttribute llzkVerif_IncludeOpGetTemplateParams(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("templateParams"));
}
 
void llzkVerif_IncludeOpSetTemplateParams(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("templateParams"), attr);
}
 
MlirAttribute llzkVerif_IncludeOpGetNumDimsPerMap(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"));
}
 
void llzkVerif_IncludeOpSetNumDimsPerMap(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("numDimsPerMap"), attr);
}
 
MlirAttribute llzkVerif_IncludeOpGetMapOpGroupSizes(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"));
}
 
void llzkVerif_IncludeOpSetMapOpGroupSizes(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("mapOpGroupSizes"), attr);
}
 
bool llzkVerif_IncludeOpContractTargetsStruct(MlirOperation inp) {
  return llvm::cast<IncludeOp>(unwrap(inp)).contractTargetsStruct();
}
 
MlirValue llzkVerif_IncludeOpGetSelfValue(MlirOperation inp) {
  return wrap(llvm::cast<IncludeOp>(unwrap(inp)).getSelfValue());
}
 
MlirType llzkVerif_IncludeOpGetTypeSignature(MlirOperation inp) {
  return wrap(llvm::cast<IncludeOp>(unwrap(inp)).getTypeSignature());
}
 
MlirOperation llzkVerif_IncludeOpResolveCallable(MlirOperation inp) {
  return wrap(llvm::cast<IncludeOp>(unwrap(inp)).resolveCallable());
}
 
MlirOperation llzkVerif_IncreasesOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.increases"), location);
  mlirOperationStateAddOperands(&state, 1, &value);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_IncreasesOp(MlirOperation inp) {
  return llvm::isa<IncreasesOp>(unwrap(inp));
}
 
MlirValue llzkVerif_IncreasesOpGetValue(MlirOperation op) {
  auto range = llvm::cast<IncreasesOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_IncreasesOpSetValue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<IncreasesOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
bool llzkOperationIsA_Verif_InvariantOp(MlirOperation inp) {
  return llvm::isa<InvariantOp>(unwrap(inp));
}
 
MlirAttribute llzkVerif_InvariantOpGetLoopName(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("loop_name"));
}
 
void llzkVerif_InvariantOpSetLoopName(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("loop_name"), attr);
}
 
MlirAttribute llzkVerif_InvariantOpGetLoopArgTypes(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("loop_arg_types"));
}
 
void llzkVerif_InvariantOpSetLoopArgTypes(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("loop_arg_types"), attr);
}
 
MlirRegion llzkVerif_InvariantOpGetRegion(MlirOperation op) {
  return mlirOperationGetRegion(op, 0);
}
 
MlirOperation llzkVerif_InvariantOpGetParentContract(MlirOperation inp) {
  return wrap(llvm::cast<InvariantOp>(unwrap(inp)).getParentContract());
}
 
MlirOperation llzkVerif_OldOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.old"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &value);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_OldOp(MlirOperation inp) {
  return llvm::isa<OldOp>(unwrap(inp));
}
 
MlirValue llzkVerif_OldOpGetValue(MlirOperation op) {
  auto range = llvm::cast<OldOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_OldOpSetValue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<OldOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkVerif_OldOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkVerif_ProveDetOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.det.prove"), location);
  mlirOperationStateEnableResultTypeInference(&state);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_ProveDetOp(MlirOperation inp) {
  return llvm::isa<ProveDetOp>(unwrap(inp));
}
 
MlirValue llzkVerif_ProveDetOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<ProveDetOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_ProveDetOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<ProveDetOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirValue llzkVerif_ProveDetOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkVerif_RequireComputeOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.require_compute"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_RequireComputeOp(MlirOperation inp) {
  return llvm::isa<RequireComputeOp>(unwrap(inp));
}
 
MlirValue llzkVerif_RequireComputeOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<RequireComputeOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_RequireComputeOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<RequireComputeOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_RequireConstrainOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.require_constrain"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_RequireConstrainOp(MlirOperation inp) {
  return llvm::isa<RequireConstrainOp>(unwrap(inp));
}
 
MlirValue llzkVerif_RequireConstrainOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<RequireConstrainOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_RequireConstrainOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<RequireConstrainOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_StepOpBuild(MlirOpBuilder builder, MlirLocation location) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.step"), location);
  llvm::SmallVector<MlirRegion, 1> regions;
  regions.push_back(mlirRegionCreate());
  mlirOperationStateAddOwnedRegions(&state, regions.size(), regions.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_StepOp(MlirOperation inp) {
  return llvm::isa<StepOp>(unwrap(inp));
}
 
MlirRegion llzkVerif_StepOpGetRegion(MlirOperation op) {
  return mlirOperationGetRegion(op, 0);
}
 
MlirOperation llzkVerif_StepYieldOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue value) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.step.yield"), location);
  mlirOperationStateAddOperands(&state, 1, &value);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_StepYieldOp(MlirOperation inp) {
  return llvm::isa<StepYieldOp>(unwrap(inp));
}
 
MlirValue llzkVerif_StepYieldOpGetValue(MlirOperation op) {
  auto range = llvm::cast<StepYieldOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_StepYieldOpSetValue(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<StepYieldOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_VerifAssertOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.assert"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_VerifAssertOp(MlirOperation inp) {
  return llvm::isa<VerifAssertOp>(unwrap(inp));
}
 
MlirValue llzkVerif_VerifAssertOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<VerifAssertOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_VerifAssertOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<VerifAssertOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_VerifProveOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.prove"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_VerifProveOp(MlirOperation inp) {
  return llvm::isa<VerifProveOp>(unwrap(inp));
}
 
MlirValue llzkVerif_VerifProveOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<VerifProveOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_VerifProveOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<VerifProveOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}
 
MlirOperation llzkVerif_VerifSMTProveOpBuild(MlirOpBuilder builder, MlirLocation location, MlirValue condition) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("verif.smt_prove"), location);
  mlirOperationStateAddOperands(&state, 1, &condition);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Verif_VerifSMTProveOp(MlirOperation inp) {
  return llvm::isa<VerifSMTProveOp>(unwrap(inp));
}
 
MlirValue llzkVerif_VerifSMTProveOpGetCondition(MlirOperation op) {
  auto range = llvm::cast<VerifSMTProveOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  return mlirOperationGetOperand(op, static_cast<intptr_t>(range.first));
}
 
void llzkVerif_VerifSMTProveOpSetCondition(MlirOperation op, MlirValue value) {
  auto range = llvm::cast<VerifSMTProveOp>(unwrap(op)).getODSOperandIndexAndLength(0);
  assert(range.second == 1 && "expected fixed operand segment size");
  assert(
      static_cast<uintptr_t>(range.first) <= static_cast<uintptr_t>(std::numeric_limits<intptr_t>::max()) &&
      "operand index exceeds intptr_t range"
  );
  mlirOperationSetOperand(op, static_cast<intptr_t>(range.first), value);
}