default:
      break;
  }
}

// Returns a default `QuantizationSpec` for performing static-range PTQ on all
// ops.
//
// In textproto, the spec corresponds to:
//
// {
//   {matcher {function_name {regex: ".*"}}
//   {method {static_range_ptq {}}}
// }
QuantizationSpec GetDefaultStaticRangePtqSpec(StaticRangePtqPreset preset) {
  QuantizationSpec spec{};
  // Default for all ops.

Status DeviceCompilationProfiler::RegisterCompilation(
    const NameAttrList& function, int64_t compile_time_us,
    bool used_persistent_cache) {
  metrics::UpdateXlaCompilationTime(compile_time_us);

  const std::string& function_name = function.name();

  mutex_lock lock(mu_);
  // Create a stats entry if it doesn't already exist.
  auto it =
      cluster_compile_stats_.emplace(function.name(), ClusterCompileStats{})
          .first;

  if (call_op->hasAttr(kQuantTraitAttrName)) {
    return;
  }

  auto function_name = call_op
                           ->getAttrOfType<FlatSymbolRefAttr>(
                               TF::kStablehloEntryFunctionAttrName)
                           .getValue();
  func::FuncOp func_op = symbol_table.lookup<func::FuncOp>(function_name);

  // We should not unwrap if the function is not from

               ? tensorflow::MlirOptimizationPassState::Enabled
               : tensorflow::MlirOptimizationPassState::Disabled;
  }

  ::tensorflow::Status Run(
      const std::string& function_name,
      const ::tensorflow::ConfigProto& config_proto, ModuleOp module,
      const ::tensorflow::Graph& graph,
      const tensorflow::FunctionLibraryDefinition& function_library) override;
};

}  // namespace TF

			}
		}
		return `PhaseOptions usage:

    go tool compile -d=ssa/<phase>/<flag>[=<value>|<function_name>]

where:

- <phase> is one of:
` + phasenames + `

- <flag> is one of:
    on, off, debug, mem, time, test, stats, dump, seed

- <value> defaults to 1

- <function_name> is required for the "dump" flag, and specifies the
  name of function to dump after <phase>

  // rhs.
  static int64_t GetDefaultQuantizationDimension(TF::XlaCallModuleOp op) {
    const StringRef function_name = GetEntryFunctionName(op);
    const auto module_op = op->getParentOfType<ModuleOp>();
    const SymbolTable symbol_table(module_op);
    func::FuncOp func = symbol_table.lookup<func::FuncOp>(function_name);

    if (function_name.contains("conv")) {
      return (*(func.getOps<mlir::stablehlo::ConvolutionOp>().begin()))

                    .map { propertyProto -> nameResolver.getName(propertyProto.name) }

                val functionNames = packageFragmentProto.`package`.functionList
                    .map { functionProto -> nameResolver.getName(functionProto.name) }

                val callableNames = (propertyNames + functionNames).distinct()
                callableNames.forEach { callableName ->

  // This should be used as a thin mapper around mlir::ModulePass::runOnModule
  // API integrated with the Tensorflow runtime.
  Status Run(const std::string& function_name, const ConfigProto& config_proto,
             mlir::ModuleOp module, const Graph& graph,
             const FunctionLibraryDefinition& function_library) override;
};

}  // namespace tfr
}  // namespace tensorflow

  // tensorflow.
  void Prepare(llvm::StringRef mlir_input);

  // Execute() can be called several times after the call to Prepare() (e.g. for
  // benchmarking).
  llvm::SmallVector<Tensor> Execute(llvm::StringRef function_name,
                                    llvm::ArrayRef<Tensor> arguments);

 private:
  void RunTfrtInitializer();

  std::unique_ptr<thread::ThreadPoolInterface> intra_op_;

                                PatternRewriter& rewriter) const override {
    const auto f_attr = mlir::dyn_cast<FlatSymbolRefAttr>(op.getFAttr());
    StringRef function_name = f_attr.getValue();
    if (!function_name.starts_with(kDequantizeFunctionName)) return failure();

    llvm::SmallVector<Operation*> users(op->getUsers().begin(),
                                        op->getUsers().end());