if (failed(MoveStandalonePreprocessingOp(&builder, getOperation(), op)))
        return signalPassFailure();
    }
    RewritePreprocessInputs(&builder, getOperation(), op);
  }

  // Handle ops with mini_batch_in_csr attribute.
  preprocess_ops.clear();
  getOperation().walk([&](Operation* op) {
    if (op->hasAttr(kMiniBatchCsrAttr)) {
      preprocess_ops.push_back(op);
    }
  });

  func::FuncOp callee = from.lookup<func::FuncOp>(symbol_ref.getValue());
  callee.getOperation()->getBlock()->getOperations().remove(
      callee.getOperation());
  to.insert(callee);
}

void TPUBridgeExecutorIslandOutlining::runOnOperation() {
  MLIRContext *ctx = &getContext();

  SymbolTable symbol_table(getOperation());
  if (Operation *nested_module = symbol_table.lookup(kNestedModule)) {

  // operation list from module_out to module_in.
  auto& module_in_ops = module_in.getBody()->getOperations();
  module_in_ops.clear();
  module_in_ops.splice(module_in_ops.end(),
                       module_out->getBody()->getOperations());
}

// Returns a vector of passes from their names. If a pass is not found, then the
// corresponding return entry is null.

  SmallVector<TF::AssignVariableOp, 16> tail_assign_variable_ops;
  llvm::SmallDenseSet<Value, 16> visited_resources;
  for (auto& op :
       llvm::reverse(replicate_op.getRegion().front().getOperations())) {
    SmallVector<Value> op_accessed_resources = GetAccessedResources(op);
    if (op_accessed_resources.empty()) continue;

    if (auto assign = llvm::dyn_cast<TF::AssignVariableOp>(op)) {

    // wrap a single op. So we'll split all islands which wrap multiple ops.
    auto control_type = tf_executor::ControlType::get(island_op.getContext());
    for (auto& execute : executes) {
      if (execute.GetBody().getOperations().size() > 1) {
        mlir::TF::SplitIsland(execute, control_type);
      }
    }
  }

  island_op.erase();
}

void ParallelExecuteToIslandsPass::runOnOperation() {

      }
    }

    // Move inner ops from island to block containing graph.
    auto &island_body = island_op.GetBody().getOperations();
    Operation *operation = op.getOperation();
    operation->getBlock()->getOperations().splice(
        operation->getIterator(), island_body, island_body.begin(),
        std::prev(island_body.end()));
    rewriter.replaceOp(op, new_rets);

                             Operation* new_yield_op) {
  Block* block = new_yield_op->getBlock();

  auto move_inner_ops = [block, new_yield_op](IslandOp island) {
    auto& island_body = island.GetBody().getOperations();
    block->getOperations().splice(new_yield_op->getIterator(), island_body,
                                  island_body.begin(),
                                  std::prev(island_body.end()));
  };

                                       Operation* module) {
  for (Block& block : region.getBlocks()) {
    StringRef current_dialect("<none>");
    std::vector<Operation*> ops;
    for (Operation& op : block.getOperations()) {
      StringRef dialect = op.getName().getDialectNamespace();
      for (Region& region : op.getRegions()) {
        // When processing nested operations, move all ops (except for func.*)

                 .getOperation();
           });

  // mlir::TF::AddOp
  py::class_<mlir::TF::AddV2Op>(m, "Tf_AddV2Op")
      .def("create",
           [](mlir::OpBuilder& opb, mlir::Location loc, mlir::Value x,
              mlir::Value y) -> mlir::Operation* {
             return opb.create<mlir::TF::AddV2Op>(loc, x, y).getOperation();
           });

        return WalkResult::interrupt();
      host_device = host_device_value;
    }
    cluster_to_host[tpu_cluster.getOperation()] = host_device;
    return tpu_cluster.walk([&](Operation* op) {
      insert_pending_op(op, tpu_cluster);
      return callback(op, tpu_cluster,
                      cluster_to_host[tpu_cluster.getOperation()]);
    });
  });
  if (result.wasInterrupted()) return failure();