<< pass_config.guarantee_all_funcs_one_use
            << "\nenable_hlo_to_tf_conversion: "
            << pass_config.enable_hlo_to_tf_conversion
            << "\nenable_stablehlo_conversion: "
            << pass_config.enable_stablehlo_conversion
            << "\nlegalize_custom_tensor_list_ops: "
            << pass_config.legalize_custom_tensor_list_ops

  pass_config.preserve_assert_op = toco_flags.preserve_assert_op();
  pass_config.guarantee_all_funcs_one_use =
      toco_flags.guarantee_all_funcs_one_use();
  pass_config.enable_stablehlo_conversion = toco_flags.convert_to_stablehlo();

  // StableHLO Quantizer is not supported for GraphDef inputs, so
  // quantization_py_function_lib is set to nullptr.
  return internal::ConvertMLIRToTFLiteFlatBuffer(

extern llvm::cl::opt<bool> disable_hlo_to_tfl_conversion;

// quantization related flags
extern llvm::cl::opt<bool> post_training_quantization;

// TF to stablehlo pass flags
extern llvm::cl::opt<bool> enable_stablehlo_conversion;

// Wether serialize stablehlo ops or not
extern llvm::cl::opt<bool> serialize_stablehlo_ops;

  pass_config.runtime_verification = true;
  pass_config.outline_tf_while = true;
  pass_config.preserve_assert_op = preserve_assert_op;
  pass_config.enable_stablehlo_conversion = enable_stablehlo_conversion;
  pass_config.legalize_custom_tensor_list_ops = legalize_custom_tensor_list_ops;
  pass_config.enable_hlo_to_tf_conversion = enable_hlo_to_tf_conversion;

    pass_config.unfold_batch_matmul = false;
  }
  pass_config.unfold_large_splat_constant =
      toco_flags.unfold_large_splat_constant();
  pass_config.enable_hlo_to_tf_conversion = true;
  pass_config.enable_stablehlo_conversion = toco_flags.convert_to_stablehlo();

  mlir::OwningOpRef<mlir::ModuleOp> module;
  if (model_flags.hlo_file_type() == toco::ModelFlags::HLO_TEXT) {

// NOLINTNEXTLINE
opt<bool> preserve_assert_op(
    "preserve-assert-op",
    llvm::cl::desc("Preserve AssertOp during tfl legalization."),
    llvm::cl::init(false));

// NOLINTNEXTLINE
opt<bool> enable_stablehlo_conversion(
    "enable-stablehlo-conversion",
    llvm::cl::desc("Enable converting TF to Stablehlo."),
    llvm::cl::init(false));

// NOLINTNEXTLINE
opt<bool> post_training_quantization(

  pass_config.preserve_assert_op = toco_flags.preserve_assert_op();
  pass_config.guarantee_all_funcs_one_use =
      toco_flags.guarantee_all_funcs_one_use();
  pass_config.enable_stablehlo_conversion = toco_flags.convert_to_stablehlo();
  pass_config.legalize_custom_tensor_list_ops =
      toco_flags.legalize_custom_tensor_list_ops();
  pass_config.enable_stablehlo_quantizer = toco_flags.has_quantization_config();

  pass_config_copy.outline_tf_while = true;

  // Checks whether the model contains an `XlaCallModuleOp` operation which
  // is a wrapper around StableHLO.
  // This option is mutually exclusive to `enable_stablehlo_conversion`, the
  // latter of which takes precedence.
  // TODO(b/290109282): explore removing the enable_hlo_to_tf_conversion flag
  // entirely, such that the added passes are no-ops in the non-shlo case.

  }

  Session* session = saved_model_bundle == nullptr
                         ? nullptr
                         : saved_model_bundle->GetSession();
  if (pass_config.enable_stablehlo_conversion) {
    // `ConvertTFExecutorToStablehloFlatbuffer` expects a `std::nullopt` if the
    // `Session*` is a nullptr.
    std::optional<Session*> session_opt =