auto fail = [&](Operation* op, std::string message) {
      op->emitError(message);
      signalPassFailure();
    };

    DenseMap<StringRef, func::FuncOp> entrypoints;
    auto module = getOperation();
    module.walk([&](func::FuncOp op) {
      auto visibility = SymbolTable::getSymbolVisibility(op);
      if (visibility != SymbolTable::Visibility::Public) return;
      entrypoints[op.getSymName()] = op;
    });

    : public impl::ConvertLaunchFuncToTFCallPassBase<
          ConvertLaunchFuncToTFCallPass> {
  void runOnOperation() override;
};

void ConvertLaunchFuncToTFCallPass::runOnOperation() {
  ModuleOp module = getOperation();
  module.walk([&](tf_device::LaunchFuncOp launch) {
    OpBuilder builder(launch);
    auto call_op = builder.create<TF::PartitionedCallOp>(
        module.getLoc(), launch.getResultTypes(), launch.getOperands(),

  cluster_func_op.replaceAllUsesWith(xla_launch_op.getResults());
  cluster_func_op.erase();
}

void XlaRewritePass::runOnOperation() {
  ModuleOp module = getOperation();
  SymbolTable symtab(module);
  OpBuilder builder(&getContext());
  module.walk([&](tf_device::ClusterFuncOp cluster_func_op) {
    RewriteCall(cluster_func_op, symtab, builder);
  });
}

}  // namespace

    for (auto namedAttr : stripAttrs) {
      func.removeResultAttr(i, namedAttr.getName());
    }
  }
}

void StripSavedModuleMetadataPass::runOnOperation() {
  auto module = getOperation();
  StripModule(module);
  module.walk(StripFunction);
}

}  // namespace

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

    for (auto namedAttr : stripAttrs) {
      func.removeResultAttr(i, namedAttr.getName());
    }
  }
}

void StripTfAttributesPass::runOnOperation() {
  ModuleOp module = getOperation();

  // strip module itself
  auto stripAttrs = llvm::to_vector<4>(llvm::make_filter_range(
      module->getAttrs(),
      [](NamedAttribute namedAttr) { return ShouldStripAttr(namedAttr); }));

    ConversionTarget target(getContext());
    target.addIllegalOp<TF::ResizeBilinearOp, TF::ResizeNearestNeighborOp>();
    target.addLegalDialect<mlir::stablehlo::StablehloDialect>();
    if (failed(applyPartialConversion(getOperation(), target,
                                      std::move(patterns)))) {
      signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> CreateSmuggleDisallowedOpsPass() {

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTFToStablehloPass)

 private:
  void runOnOperation() override;
};

void TestTFToStablehloPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext* ctx = &getContext();
  mlir::PassManager pm(ctx);

  AddTFToStablehloPasses(pm);
  if (!RunPassesOnModuleOp(
           /*mlir_dump_file_name=*/"test_tf_to_stablehlo_pass", pm, module_op)

	})
	return l.convertedOldObject, l.convertedOldObjectError
}

func (l *lazyConvertingAttributes) GetOperation() admissionv1.Operation {
	return admissionv1.Operation(l.Attributes.GetOperation())
}

func (l *lazyConvertingAttributes) GetUserName() string {
	return l.GetUserInfo().GetName()
}

func convert(in runtime.Object) (runtime.Object, error) {

	// attest check.
	if newBundle.Spec.SignerName == "" {
		return nil
	}

	// Skip the attest check when the semantics of the bundle are unchanged to support storage migration and GC workflows
	if a.GetOperation() == admission.Update && rbac.IsOnlyMutatingGCFields(a.GetObject(), a.GetOldObject(), kapihelper.Semantic) {
		return nil
	}

  // TODO: b/321729008 - move this implementation to quantization_patterns.cc.
  if (merge_fusion_with_dequantize_) {
    pm.addPass(createMergeFusionWithDequantizePass());
  }

  ModuleOp module_op = getOperation();
  if (const absl::Status pm_run_status =
          RunPassesOnModuleOp(mlir_dump_file_name_, pm, module_op);
      !pm_run_status.ok()) {
    signalPassFailure();
  }
}

}  // namespace