mlir::registerTensorFlowPasses();
  mlir::quant::stablehlo::registerPasses();
  mlir::quant::stablehlo::registerBridgePasses();
  mlir::stablehlo::registerPasses();
  mlir::mhlo::registerAllMhloPasses();
  // These passes are only used for testing purposes.
  mlir::quant::stablehlo::testing::registerTestPasses();

  // Register StableHLO Quantizer pass pipelines.
  mlir::quant::stablehlo::RegisterPassPipelines();

    'mlir-opt',
    'mlir-tflite-runner',
    'mlir-translate',
    'odml-to-stablehlo-opt',
    'odml_to_stablehlo',
    'odml-converter',
    'stable-quant-opt',
    'tac-opt-all-backends',
    'tac-translate',
    'tf-mlir-translate',
    'tf-opt',
    'tf-quant-opt',
    'tf-reduce',
    'tf-tfrt-opt',
    'tf_tfjs_translate',
    'tf_tfl_translate',
    'tfcompile',
    'tfg-opt-no-passes',

  return IsOpSupported(op, "CPU");
}

std::optional<std::string> GetDeviceName(mlir::Operation* op) {
  if (IsConst(op)) return std::nullopt;

  // The model may contain quant stats op which is unrelevant to the
  // execution.
  if (llvm::isa<mlir::func::ReturnOp, mlir::quantfork::StatisticsOp>(op))
    return std::nullopt;

  if (!HasValidHardwareTarget(op)) return std::nullopt;

// reaching feature parity with the old quantizer for dynamic range
// quantization, specifically for
// third_party/tensorflow/lite/tools/optimize/quantize_weights.h.
// TODO(b/202468183): Selective quantization + quant debugger support for
// dynamic range quantization for verify_numeric and whole_model_verify flags.
TfLiteStatus QuantizeWeights(
    flatbuffers::FlatBufferBuilder* builder, const tflite::Model* input_model,

  PassManager pm((*module)->getName(), OpPassManager::Nesting::Implicit);
  if (debug_options.has_value()) {
    // Add debugging instrumentation
    tensorflow::InitPassManager(pm, debug_options.value());
  }
  quant::QuantizationSpecs quant_specs;
  quant_specs.inference_type = tflite::TflTypeToTfType(inference_type);
  quant_specs.post_training_quantization = true;
  quant_specs.disable_per_channel = disable_per_channel;

      serialized_model, &context, UnknownLoc::get(&context));

  // Apply quantization passes.
  PassManager pm((*module)->getName(), OpPassManager::Nesting::Implicit);
  quant::QuantizationSpecs quant_specs;
  quant_specs.inference_type = tflite::TflTypeToTfType(inference_type);
  quant_specs.weight_quantization = true;
  quant_specs.weight_only_quantization = weight_only_quantization;

    }
  } else if (auto q_uniform_type =
                 mlir::dyn_cast<mlir::quant::UniformQuantizedType>(type)) {
    return GetTFLiteType(q_uniform_type.getStorageType(),
                         q_uniform_type.isSigned());
  } else if (auto q_peraxis_type =
                 mlir::dyn_cast<mlir::quant::UniformQuantizedPerAxisType>(
                     type)) {

#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"  // from @llvm-project
#include "mlir/Dialect/Arith/IR/Arith.h"  // from @llvm-project
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/Dialect/Quant/QuantOps.h"  // from @llvm-project
#include "mlir/IR/Attributes.h"  // from @llvm-project
#include "mlir/IR/Block.h"  // from @llvm-project
#include "mlir/IR/BuiltinAttributes.h"  // from @llvm-project

  // multi-threaded.
  let dependentDialects = [
    "chlo::ChloDialect",
    "mhlo::MhloDialect",
    "shape::ShapeDialect",
    "stablehlo::StablehloDialect",
    "vhlo::VhloDialect",
    "quant::QuantizationDialect",
  ];

  let constructor = "TF::CreateXlaCallModuleDeserializationPass()";
}

def XlaCallModuleSerializationPass
    : Pass<"tf-xla-call-module-serialization", "ModuleOp"> {

	if r == nil {
		return
	}

	for rName, rQuant := range rl {
		switch rName {
		case v1.ResourceCPU:
			r.MilliCPU += rQuant.MilliValue()
		case v1.ResourceMemory:
			r.Memory += rQuant.Value()
		case v1.ResourcePods:
			r.AllowedPodNumber += int(rQuant.Value())
		case v1.ResourceEphemeralStorage:
			r.EphemeralStorage += rQuant.Value()
		default:
			if schedutil.IsScalarResourceName(rName) {