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

    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:

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

    mlir::SymbolRefAttr sym = callable.dyn_cast<mlir::SymbolRefAttr>();
    auto symbol =
        mlir::SymbolTable::lookupNearestSymbolFrom(call.getOperation(), sym);
    if (!symbol) return failure();
    auto f = llvm::dyn_cast<mlir::func::FuncOp>(symbol);

    if (call.getOperation()->getNumOperands() !=
        f.getBody().front().getNumArguments()) {
      return failure();  // RemoteCall et al
    }

    Operation* inlined_point = call_op.getOperation();
    Operation* after_inlined_point =
        &*std::next(Block::iterator(call_op.getOperation()));

    // Use the inliner to replace all the uses of the call_op by its
    // composition.
    if (failed(inlineCall(inliner,
                          cast<CallOpInterface>(call_op.getOperation()),

             << ")";
    }
  }
  return success();
}

void GraphOp::print(OpAsmPrinter &p) {
  p << ' ';
  p.printRegion(getOperation()->getRegion(0));
  p.printOptionalAttrDict(getOperation()->getAttrs());
}

ParseResult GraphOp::parse(OpAsmParser &parser, OperationState &result) {
  llvm::SMLoc loc = parser.getCurrentLocation();

  // Parse the body region.

          operand->get().getType() ==
              ShuffleRankedTensorType(ranked_tranpose_type, permutation)) {
        TransposeOp transpose = tranpose_op;
        transpose.getOperation()->moveBefore(op);
        transpose.setOperand(0, operand->get());
        transpose.setOperand(1, permutation_op);
        transpose_ops->erase(it);
        return transpose;
      }
    }
  }

  LogicalResult matchAndRewrite(OpTy op,
                                PatternRewriter& rewriter) const override {
    if (op.getOperation()->template hasTrait<OpTrait::IsTerminator>()) {
      return failure();
    }
    for (auto result : op.getOperation()->getOpResults()) {
      if (!result.use_empty()) {
        return failure();
      }
    }

    }
  }
}

void TpuV1BridgeExecutorIslandCoarsening::runOnOperation() {
  SymbolTable symbol_table(getOperation());

  // Map tpu cluster names to the functions that contain operations for this
  // cluster.
  DenseMap<StringRef, DenseSet<func::FuncOp>> tpu_funcs;
  for (func::FuncOp func_op : getOperation().getOps<func::FuncOp>()) {
    func_op.walk([&](Operation* op) {

    func.getAllResultAttrs(tmp);

    for (const auto& res : tmp) {
      result_attrs.push_back(res.getValue().vec());
    }
  }

  mlir::Builder builder(func.getOperation());

  for (OpOperand& operand : fetch.getOperation()->getOpOperands()) {
    if (mlir::isa<tf_executor::ControlType>(operand.get().getType())) break;
    auto it = value_to_device.find(operand.get());
    if (it != value_to_device.end()) {