// referred logic from mlir::mlirTranslateMain().

  std::string errorMessage;
  std::unique_ptr<llvm::MemoryBuffer> input;
  if (input_is_filepath) {
    input = mlir::openInputFile(model_file_or_buffer, &errorMessage);
    if (!input) {
      llvm::errs() << errorMessage << "\n";
      return "";
    }
  } else {
    input = llvm::MemoryBuffer::getMemBuffer(model_file_or_buffer, "flatbuffer",

  TF_ASSERT_OK(mlir::TF::RunBridgeWithStandardPipeline(
      module_ref.get(),
      /*enable_logging=*/true, /*enable_inliner=*/false));

  std::string errorMessage;
  auto input_file = mlir::openInputFile(filepath, &errorMessage);
  EXPECT_THAT(input_file, Not(IsNull()));

  auto output_stream = mlir::openOutputFile(output_dump, &errorMessage);
  EXPECT_THAT(output_stream, Not(IsNull()));

    const std::vector<std::string>& tag_names, bool is_input_mlir_module) {
  if (is_input_mlir_module) {
    std::string error_message;
    std::unique_ptr<llvm::MemoryBuffer> file =
        openInputFile(input_path, &error_message);
    if (!file) {
      return absl::AbortedError(
          absl::StrCat("Failed to parse input MLIR model: ", error_message));
    }

    llvm::SourceMgr source_mgr;

          tensorflow::io::JoinPath("assets",
                                   tensorflow::io::Basename(filename)));
    }

    // Read the content of the file.
    std::string error_message;
    auto file = openInputFile(filename, &error_message);
    if (!file) {
      return op.emitOpError("failed to open vocabulary file")
             << " (" << filename << "): " << error_message;
    }

    // Splits into lines.

    bool experimental_prune_unreachable_nodes_unconditionally,
    llvm::SourceMgr* source_mgr, mlir::MLIRContext* context) {
  std::string error;
  std::unique_ptr<llvm::MemoryBuffer> buffer =
      mlir::openInputFile(input_filename, &error);
  if (buffer == nullptr) {
    return absl::InvalidArgumentError(absl::StrFormat(
        "Cannot open input file: %s. %s", input_filename, error));
  }

  if (input_mlir) {

        &bundle);
  } else if (import_hlo) {
    // HLO import path.
    std::string error;
    std::unique_ptr<llvm::MemoryBuffer> buffer =
        mlir::openInputFile(input_file_name, &error);
    if (buffer == nullptr) {
      llvm::errs() << "Cannot open input file: " << input_file_name << " "
                   << error;
      return kTrFailure;
    }

        input_filename, tags, exported_names, &context, import_options);
    if (!module_or.status().ok()) return 1;

    module_or.value()->print(output->os());
  } else {
    auto input = mlir::openInputFile(input_filename, &error_message);

    if (!input) {
      llvm::errs() << error_message << "\n";
      return 1;
    }

    // Processes the memory buffer with a new MLIRContext.

    });
    signalPassFailure();
  };
};

absl::StatusOr<OwningOpRef<mlir::ModuleOp>> LoadModule(
    MLIRContext* context, const std::string& file_name) {
  std::string error_message;
  auto file = openInputFile(file_name, &error_message);
  if (!file) {
    return tensorflow::errors::InvalidArgument("fail to open input file");
  }

  llvm::SourceMgr source_mgr;

  mlir::StatusScopedDiagnosticHandler diagnostic_handler(&context);
  {
    mlir::Location loc = mlir::UnknownLoc::get(&context);
    std::string error;
    std::unique_ptr<llvm::MemoryBuffer> buffer =
        mlir::openInputFile(flatbuffer_file, &error);
    if (buffer == nullptr) {
      TF_SetStatus(status, TF_INVALID_ARGUMENT,
                   ("Unable to load input file " + error).c_str());
      return;
    }

    absl::string_view control_output_arrays, llvm::SourceMgr* source_mgr,
    MLIRContext* context) {
  // Set up the input file.
  std::string error_message;
  auto file = mlir::openInputFile(input_filename, &error_message);
  if (!file) {
    return absl::InvalidArgumentError(
        absl::StrCat("Failed to open input file: ", error_message));
  }

  if (input_mlir) {