for (func::FuncOp func_op :
       llvm::make_early_inc_range(nested_block.getOps<func::FuncOp>())) {
    if (!symbol_table.lookupSymbolIn(getOperation(), func_op.getName())) {
      nested_block.getOperations().remove(func_op.getOperation());
      symbol_table.insert(func_op.getOperation());
    }
  }
  nested_module->erase();
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>

// order of ops in tf_executor.graph.
LogicalResult LiftIslandOpInnerOpsFromGraph(tf_executor::GraphOp graph) {
  auto graph_position = graph.getOperation()->getIterator();
  Block* parent_block = graph.getOperation()->getBlock();
  for (Operation& op : graph.GetBody().without_terminator()) {
    auto island_op = llvm::dyn_cast<tf_executor::IslandOp>(op);
    if (!island_op)
      return op.emitOpError()

    if (!op.isPrivate()) return;

    auto call = llvm::dyn_cast<CallableOpInterface>(op.getOperation());
    if (!call) return;
    Region* region = call.getCallableRegion();
    if (!region) return;  // happens e.g. for external functions

    auto func = llvm::dyn_cast<FunctionOpInterface>(op.getOperation());
    if (!func || do_not_touch.count(func)) return;
    llvm::BitVector unused_args(func.getNumArguments());

      input_shapes_ = input_shapes_vec;
    }

    auto failure_or_converged = InferModuleShape(
        getOperation(), max_iterations_, /*ops_to_skip=*/{}, input_shapes_);
    if (failed(failure_or_converged)) return signalPassFailure();
    if (!failure_or_converged.value()) {
      getOperation().emitError()
          << "shape inference pass did not reach convergence after "
          << max_iterations_;

  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)) {

  if (op->hasAttr("_wraps_compilation")) return 1;
  // Followed by everything else.
  return 0;
}

void MoveTpuCompileToFrontPass::runOnOperation() {
  MarkCompilationOps(getOperation());
  getOperation().walk([](Operation* op) {
    for (Region& region : op->getRegions()) {
      for (Block& block : region.getBlocks()) {
        if (block.empty()) continue;

  // Move all inner ops of the launch to the block containing the launch.
  auto body = launch.GetBody().without_terminator();
  Operation* launch_op = launch.getOperation();
  launch_op->getBlock()->getOperations().splice(
      launch_op->getIterator(), launch.GetBody().getOperations(), body.begin(),
      body.end());

  launch.erase();

  return success();
}

void LaunchToDeviceAttributePass::runOnOperation() {

		}
		return nil

	default:
		return admission.NewForbidden(a, fmt.Errorf("unexpected operation %s", a.GetOperation()))
	}
}

func (p *Plugin) admitPVCStatus(nodeName string, a admission.Attributes) error {
	switch a.GetOperation() {
	case admission.Update:
		oldPVC, ok := a.GetOldObject().(*api.PersistentVolumeClaim)
		if !ok {

      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);
    }
  });

    rewriter.setInsertionPointToEnd(&func.getBody().front());
    rewriter.create<func::ReturnOp>(
        loc, executor_graph.getOperation()->getResults());

    rewriter.replaceOp(graph_func.getOperation(),
                       func.getOperation()->getResults());

    return success();
  }
};

class ConvertReturnOp : public OpConversionPattern<tfg::ReturnOp> {
 public: