if (auto block_arg = mlir::dyn_cast<BlockArgument>(value))
    return block_arg.getOwner()->getParentOp();

  return value.getDefiningOp();
}

void TPUAnnotateDynamicShapeInputsPass::runOnOperation() {
  getOperation().walk([&](tf_device::ClusterFuncOp cluster_func_op) {
    Builder builder(cluster_func_op->getContext());
    // Skip non-tpu device cluster_func.
    auto cluster_id =

  // TODO: b/304003568 - Add TF_TransposeOp folding logic to tflite.
  target.addIllegalOp<mhlo::DotGeneralOp, mhlo::DotOp, mhlo::TransposeOp>();
  if (failed(applyPartialConversion(getOperation(), target,
                                    std::move(patterns)))) {
    getOperation().emitError("mhlo to TFLite legalization failed.");
    signalPassFailure();
  }
}
}  // namespace

    var_handle_op.erase();
  }
}

void QuantizeVariablesPass::runOnOperation() {
  ResourceIdMap resource_id_map;
  ResourceMap resource_map;

  // Collect all resource identities.
  getOperation().walk([&](TFL::VarHandleOp var_handle_op) {
    auto identity = std::make_pair(var_handle_op.getContainer().str(),
                                   var_handle_op.getSharedName().str());
    resource_id_map.insert(

    if (op.use_empty() &&
        (op.getIsStateless() ||
         (IsSideEffectFree(then_func) && IsSideEffectFree(else_func)))) {
      rewriter.eraseOp(op.getOperation());
      return success();
    }

    // Extract the constant cond value.
    DenseElementsAttr cond;
    if (!matchPattern(op.getCond(), m_Constant(&cond))) return failure();

 public:
  // void runOnOperation() override;
  void runOnOperation() override {
    // Strip the "tf._noinline" attribute from top-level functions.
    for (auto func_op : getOperation().getOps<func::FuncOp>())
      func_op->removeAttr("tf._noinline");
  }
};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateStripNoinlineAttributePass() {

struct FreezeVariableTestPass
    : public impl::FreezeVariablesTestPassBase<FreezeVariableTestPass> {
  void runOnOperation() override {
    TF::test_util::FakeSession session;
    if (tf_saved_model::FreezeVariables(getOperation(), &session).failed())
      signalPassFailure();
  }
};
}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateFreezeVariableTestPass() {
  return std::make_unique<FreezeVariableTestPass>();
}

class VerifySuitableForExportPass
    : public impl::VerifySuitableForExportPassBase<
          VerifySuitableForExportPass> {
 public:
  void runOnOperation() override {
    if (failed(tensorflow::VerifyExportSuitable(getOperation())))
      return signalPassFailure();
  }
};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateVerifySuitableForExportPass() {
  return std::make_unique<VerifySuitableForExportPass>();
}

class SHLOSimplifyPass : public impl::SHLOSimplifyPassBase<SHLOSimplifyPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SHLOSimplifyPass)

  void runOnOperation() override {
    ModuleOp module = getOperation();
    RewritePatternSet patterns(&getContext());
    populateWithGenerated(patterns);
    PopulateFolderPatterns(patterns);
    if (failed(applyPatternsAndFoldGreedily(module, std::move(patterns)))) {

	validatingAdmission, isValidatingAdmission := admit.(admission.ValidationInterface)

	mutating := isMutatingAdmission && mutatingAdmission.Handles(staticAttributes.GetOperation())
	validating := isValidatingAdmission && validatingAdmission.Handles(staticAttributes.GetOperation())

	return func(ctx context.Context, old runtime.Object) error {
		if !mutating && !validating {
			return nil
		}

	if code > 600 {
		code = 600
	}
	m.webhookRequest.WithContext(ctx).WithLabelValues(name, stepType, string(attr.GetOperation()), strconv.Itoa(code), strconv.FormatBool(rejected)).Inc()
	m.webhook.observe(ctx, elapsed, name, stepType, string(attr.GetOperation()), strconv.FormatBool(rejected))
}

// ObserveWebhookRejection records admission related metrics for an admission webhook rejection.