}
  return bytecode;
}

absl::StatusOr<std::string> ExportModule(ModuleOp module) {
  const std::string output_filename = tensorflow::io::GetTempFilename(".mlir");
  std::string error_msg;
  auto output = openOutputFile(output_filename, &error_msg);
  if (output == nullptr) {
    return absl::UnknownError(
        absl::StrCat("Unable to open output path: ", error_msg));
  }

}  // namespace

namespace mlir {

namespace {
// Dump the ModuleOp 'module' to the file specified using 'outputFileName'
absl::Status ExportModule(ModuleOp module) {
  std::string error_msg;
  auto output = openOutputFile(output_filename, &error_msg);
  if (output == nullptr) {
    return absl::AbortedError(
        absl::StrCat("Unable to write to output path: ", error_msg));
  }

                                                 llvm::cl::desc("<input file>"),
                                                 llvm::cl::init("-"));

// NOLINTNEXTLINE
static llvm::cl::opt<std::string> output_filename(
    "o", llvm::cl::desc("Output filename"), llvm::cl::value_desc("filename"),
    llvm::cl::init("-"));

// NOLINTNEXTLINE
static llvm::cl::opt<bool> splitInputFile(
    "split-input-file",

}

absl::Status ExportFlatbufferOrMlir(const std::string& output_filename,
                                    bool output_mlir, mlir::ModuleOp module,
                                    bool enable_select_tf_ops) {
  std::string error_msg;
  auto output = mlir::openOutputFile(output_filename, &error_msg);
  if (output == nullptr) {
    llvm::errs() << error_msg << '\n';

    llvm::SourceMgr* source_mgr, mlir::MLIRContext* context);

// Export the module to file, can be either mlir or flatbuffer.
absl::Status ExportFlatbufferOrMlir(const std::string& output_filename,
                                    bool output_mlir, mlir::ModuleOp module,
                                    bool enable_select_tf_ops);

}  // namespace tac
}  // namespace TFL
}  // namespace mlir

}

tensorflow::Status ExportModule(mlir::ModuleOp module,
                                const std::string& output_filename,
                                bool elide_large_elements_attrs) {
  std::string error_msg;
  auto output = mlir::openOutputFile(output_filename, &error_msg);
  if (output == nullptr) {
    llvm::errs() << error_msg << '\n';

  using '?' for unknown sizes. For example, `input-arg-shapes=1,2::1,?`
  expresses argument shapes `[1,2]`, `[]` and `[1,?]`.
* `--e`: Elide large elements attrs while dumping the output StableHLO.
* `--output_filename`: Path to the output file where the textual StableHLO MLIR
  module will be written (default: stdout).


### Examples

* To convert [microsoft/resnet-50](https://huggingface.co/microsoft/resnet-50)

	// Calculate the output file name
	var outputFileName string
	switch {
	case strings.HasSuffix(inputFileName, ".enc"):
		outputFileName = strings.TrimSuffix(inputFileName, ".enc") + ".zip"
	case strings.HasSuffix(inputFileName, ".zip"):
		outputFileName = strings.TrimSuffix(inputFileName, ".zip") + ".decrypted.zip"
	case strings.Contains(inputFileName, ".enc."):
		outputFileName = strings.Replace(inputFileName, ".enc.", ".", 1) + ".zip"

}

std::unique_ptr<mlir::TFL::tac::TacExporter> CreateTfLiteExporter(
    const std::string output_file_name,
    const std::vector<std::string>& target_hardware_backends) {
  mlir::TFL::tac::TfLiteExporter::Options options;
  options.output_mlir = false;
  options.output_file_name = output_file_name;
  options.export_runtime_metadata = false;
  options.target_hardware_backends = target_hardware_backends;

    const std::vector<std::string>& target_hardware_backends) {
  mlir::TFL::tac::TfLiteExporter::Options options;
  options.output_mlir = output_mlir;
  options.output_file_name = output_file_name;
  options.export_runtime_metadata = export_runtime_metadata;
  options.target_hardware_backends = target_hardware_backends;
  return std::make_unique<mlir::TFL::tac::TfLiteExporter>(options);
}