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                                                               *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
 
MlirOperation llzkFelt_AddFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.add"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_AddFeltOp(MlirOperation inp) {
  return llvm::isa<AddFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_AddFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_AddFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_AddFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_AddFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_AddFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_AndFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.bit_and"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_AndFeltOp(MlirOperation inp) {
  return llvm::isa<AndFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_AndFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_AndFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_AndFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_AndFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_AndFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_DivFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.div"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_DivFeltOp(MlirOperation inp) {
  return llvm::isa<DivFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_DivFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_DivFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_DivFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_DivFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_DivFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_FeltConstantOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirAttribute value) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.const"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  MlirContext ctx = mlirOpBuilderGetContext(builder);
  llvm::SmallVector<MlirNamedAttribute, 1> attributes;
  if (!mlirAttributeIsNull(value)) {
    attributes.push_back(mlirNamedAttributeGet(mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("value")), value));
  }
  mlirOperationStateAddAttributes(&state, attributes.size(), attributes.data());
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_FeltConstantOp(MlirOperation inp) {
  return llvm::isa<FeltConstantOp>(unwrap(inp));
}
 
MlirAttribute llzkFelt_FeltConstantOpGetValue(MlirOperation op) {
  return mlirOperationGetAttributeByName(op, mlirStringRefCreateFromCString("value"));
}
 
void llzkFelt_FeltConstantOpSetValue(MlirOperation op, MlirAttribute attr) {
  mlirOperationSetAttributeByName(op, mlirStringRefCreateFromCString("value"), attr);
}
 
MlirValue llzkFelt_FeltConstantOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_InvFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue operand) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.inv"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &operand);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_InvFeltOp(MlirOperation inp) {
  return llvm::isa<InvFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_InvFeltOpGetOperand(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_InvFeltOpSetOperand(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_InvFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_MulFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.mul"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_MulFeltOp(MlirOperation inp) {
  return llvm::isa<MulFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_MulFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_MulFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_MulFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_MulFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_MulFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_NegFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue operand) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.neg"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &operand);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_NegFeltOp(MlirOperation inp) {
  return llvm::isa<NegFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_NegFeltOpGetOperand(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_NegFeltOpSetOperand(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_NegFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_NotFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue operand) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.bit_not"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &operand);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_NotFeltOp(MlirOperation inp) {
  return llvm::isa<NotFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_NotFeltOpGetOperand(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_NotFeltOpSetOperand(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_NotFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_OrFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.bit_or"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_OrFeltOp(MlirOperation inp) {
  return llvm::isa<OrFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_OrFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_OrFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_OrFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_OrFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_OrFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_PowFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.pow"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_PowFeltOp(MlirOperation inp) {
  return llvm::isa<PowFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_PowFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_PowFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_PowFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_PowFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_PowFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_ShlFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.shl"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_ShlFeltOp(MlirOperation inp) {
  return llvm::isa<ShlFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_ShlFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_ShlFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_ShlFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_ShlFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_ShlFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_ShrFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.shr"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_ShrFeltOp(MlirOperation inp) {
  return llvm::isa<ShrFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_ShrFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_ShrFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_ShrFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_ShrFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_ShrFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_SignedIntDivFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.sintdiv"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_SignedIntDivFeltOp(MlirOperation inp) {
  return llvm::isa<SignedIntDivFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_SignedIntDivFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_SignedIntDivFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_SignedIntDivFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_SignedIntDivFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_SignedIntDivFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_SignedModFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.smod"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_SignedModFeltOp(MlirOperation inp) {
  return llvm::isa<SignedModFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_SignedModFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_SignedModFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_SignedModFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_SignedModFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_SignedModFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_SubFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.sub"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_SubFeltOp(MlirOperation inp) {
  return llvm::isa<SubFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_SubFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_SubFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_SubFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_SubFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_SubFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_UnsignedIntDivFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.uintdiv"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_UnsignedIntDivFeltOp(MlirOperation inp) {
  return llvm::isa<UnsignedIntDivFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_UnsignedIntDivFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_UnsignedIntDivFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_UnsignedIntDivFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_UnsignedIntDivFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_UnsignedIntDivFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_UnsignedModFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.umod"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_UnsignedModFeltOp(MlirOperation inp) {
  return llvm::isa<UnsignedModFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_UnsignedModFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_UnsignedModFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_UnsignedModFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_UnsignedModFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_UnsignedModFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}
 
MlirOperation llzkFelt_XorFeltOpBuild(MlirOpBuilder builder, MlirLocation location, MlirType resultType, MlirValue lhs, MlirValue rhs) {
  MlirOperationState state = mlirOperationStateGet(mlirStringRefCreateFromCString("felt.bit_xor"), location);
  mlirOperationStateAddResults(&state, 1, &resultType);
  mlirOperationStateAddOperands(&state, 1, &lhs);
  mlirOperationStateAddOperands(&state, 1, &rhs);
 
  return mlirOpBuilderInsert(builder, mlirOperationCreate(&state));
}
 
bool llzkOperationIsA_Felt_XorFeltOp(MlirOperation inp) {
  return llvm::isa<XorFeltOp>(unwrap(inp));
}
 
MlirValue llzkFelt_XorFeltOpGetLhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 0);
}
 
void llzkFelt_XorFeltOpSetLhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 0, value);
}
 
MlirValue llzkFelt_XorFeltOpGetRhs(MlirOperation op) {
  return mlirOperationGetOperand(op, 1);
}
 
void llzkFelt_XorFeltOpSetRhs(MlirOperation op, MlirValue value) {
  mlirOperationSetOperand(op, 1, value);
}
 
MlirValue llzkFelt_XorFeltOpGetResult(MlirOperation op) {
  return mlirOperationGetResult(op, 0);
}