.def("setInsertionPoint",
           py::overload_cast<mlir::Block*, mlir::Block::iterator>(
               &mlir::OpBuilder::setInsertionPoint))
      .def("saveInsertionPoint", &mlir::OpBuilder::saveInsertionPoint)
      .def("restoreInsertionPoint", &mlir::OpBuilder::restoreInsertionPoint)
      .def(
          "create",
          [](mlir::OpBuilder& opb, mlir::OperationState& state) {

                                         mlir::Operation* op,
                                         llvm::StringRef device) {
  mlir::OpBuilder::InsertPoint insert_point = builder->saveInsertionPoint();

  auto launch = builder->create<mlir::tf_device::LaunchOp>(
      loc, builder->getStringAttr(device), op->getResultTypes());
  launch.getBody().push_back(new mlir::Block);

    def create(self, *args, **kwargs) -> Any: ...
    def getContext(self) -> MLIRContext: ...
    def getUnknownLoc(self) -> Location: ...
    def restoreInsertionPoint(self, arg0) -> None: ...
    def saveInsertionPoint(self, *args, **kwargs) -> Any: ...
    def setInsertionPoint(self, arg0: Block, arg1: Block_Iterator) -> None: ...

class OpBuilder_InsertionPoint:
    def __init__(self, *args, **kwargs) -> None: ...

                             QuantizedType)>
        quantization_operations_func) {
  Operation* input_op = input_val.getDefiningOp();
  auto original_point = rewriter.saveInsertionPoint();

  auto unique_func_name = func_name.str();
  SymbolTable symbol_table(input_op->getParentOfType<ModuleOp>());
  while (symbol_table.lookup(unique_func_name)) {
    absl::StrAppend(&unique_func_name, "_");

  // Note, 'inputs' and 'outputs' are the predetermined set of values that
  // should become the operands and return values, respectively.
  auto saved_insertion_point = builder.saveInsertionPoint();
  func::FuncOp new_func =
      CreateFnWithSignature(module, symbol_table, inputs, outputs, name);

  // This preserves the order of the ops that was in the original parent

void WrapOpInLaunch(OpBuilder* builder, Location loc, Operation* op,
                    llvm::StringRef device) {
  OpBuilder::InsertPoint insert_point = builder->saveInsertionPoint();

  auto launch = builder->create<tf_device::LaunchOp>(
      loc, builder->getStringAttr(device), op->getResultTypes());
  launch.getBody().push_back(new Block);

  // Note, 'inputs' and 'outputs' are the predetermined set of values that
  // should become the operands and return values, respectively.
  auto insertion_point = builder.saveInsertionPoint();
  func::FuncOp new_func = CreateFnWithSignature(module, inputs, outputs,
                                                absl::StrCat("_func_", name));

    // Create functions in a higher scope before restoring the insertion point.
    // Additionally, create the SymbolTable before further modifying the module.
    auto original_point = rewriter.saveInsertionPoint();
    rewriter.setInsertionPointAfter(op->getParentOfType<func::FuncOp>());
    SymbolTable manager(op->getParentOfType<ModuleOp>());

    // Constructs `then_branch`, which is executed when `if_cond` evaluates to

  if (maybe_control_node == control_nodes->end()) {
    return op->getResults();
  }
  mlir::Region region;
  region.push_back(new mlir::Block);
  auto saved_pos = op_builder.saveInsertionPoint();
  op_builder.setInsertionPointToEnd(&region.front());
  mlir::Operation* cloned_op = op_builder.clone(*op);
  // Add the yield operation.
  op_builder.create<mlir::TFL::YieldOp>(op_loc, cloned_op->getResults());