// to pull in a lot of code.

package main

import (
	"net/http"
	"net/http/httptest"
)

type statusHandler int

func (h *statusHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(int(*h))
}

func main() {
	status := statusHandler(http.StatusNotFound)
	s := httptest.NewServer(&status)
	defer s.Close()

namespace quantization {

absl::Status RunPassesOnModuleOp(
    std::optional<absl::string_view> mlir_dump_file_name,
    mlir::PassManager& pass_manager, mlir::ModuleOp module_op) {
  mlir::StatusScopedDiagnosticHandler statusHandler(module_op.getContext(),
                                                    /*propagate=*/true);

  absl::StatusOr<std::unique_ptr<llvm::raw_ostream>> dump_file;
  if (mlir_dump_file_name) {

  pm.addPass(TFL::CreateDenseToSparsePass());

  if (failed(pm.run(module.get()))) {
    LOG(ERROR) << "Failed to sparsify: "
               << statusHandler.ConsumeStatus().message();
    return absl::InternalError(absl::StrCat(
        "Failed to sparsify: ", statusHandler.ConsumeStatus().message()));
  }

  // Export the results to the builder
  std::string result;
  tflite::FlatbufferExportOptions options;

    denylisted_mlir_op_names.insert(TfLiteToMlir(entry));
  }

  DialectRegistry registry;
  registry.insert<mlir::TFL::TensorFlowLiteDialect>();
  MLIRContext context(registry);
  StatusScopedDiagnosticHandler statusHandler(&context,
                                              /*propagate=*/true);

  OwningOpRef<mlir::ModuleOp> module = tflite::FlatBufferToMlir(
      model_buffer, &context, UnknownLoc::get(&context));
  if (!module) {

  for (auto& entry : denylisted_ops) {
    denylisted_mlir_op_names.insert(TfLiteToMlir(entry));
  }

  DialectRegistry registry;
  MLIRContext context(registry);
  StatusScopedDiagnosticHandler statusHandler(&context,
                                              /*propagate=*/true);

  // Import input_model to a MLIR module
  flatbuffers::FlatBufferBuilder input_builder;

    const bool deserialize_xla_call_module,
    llvm::ArrayRef<llvm::ArrayRef<int64_t>> input_arg_shapes) {
  mlir::PassManager pm_before_freezing_variables(context);
  mlir::StatusScopedDiagnosticHandler statusHandler(module_op.getContext(),
                                                    /*propagate=*/true);

  mlir::TF::StandardPipelineOptions standard_pipeline_options;
  standard_pipeline_options.enable_inliner = false;

  AddTACPass(&pm, options_.hardware_backends);
  if (!debug_mode) {
    AddExportTFLPass(&pm, options_.enable_inliner);
  }

  mlir::StatusScopedDiagnosticHandler statusHandler(module->getContext(),
                                                    /*propagate=*/true);
  if (failed(pm.run(*module))) {
    return absl::InternalError("conversion error");
  }
  return absl::OkStatus();
}

Status ConvertTFExecutorToStablehloFlatbuffer(
    mlir::PassManager& pass_manager, mlir::ModuleOp module, bool export_to_mlir,
    mlir::StatusScopedDiagnosticHandler& statusHandler,
    const toco::TocoFlags& toco_flags, const mlir::TFL::PassConfig& pass_config,
    std::optional<tensorflow::Session*> session, std::string* result);

// Taking a MLIR module in TF executor dialect and a set of parameters,

                   ("Invalid pass_pipeline: " + error_stream.str()).c_str());
      return "// error";
    }

    mlir::StatusScopedDiagnosticHandler statusHandler(module.getContext());
    if (failed(pm.run(module))) {
      tsl::Set_TF_Status_from_Status(status, statusHandler.ConsumeStatus());
      return "// error";
    }
  }
  return MlirModuleToString(module, show_debug_info);
}

}  // anonymous namespace

    return status_handler.ConsumeStatus();
  }
  if (export_to_mlir) {
    llvm::raw_string_ostream os(*result);
    module.print(os);
    return status_handler.ConsumeStatus();
  }
  pass_manager.clear();
  pass_manager.addPass(mlir::odml::createLegalizeStablehloToVhloPass());
  if (failed(pass_manager.run(module))) {
    return status_handler.Combine(