}

template <class T>
Status LoadProtoFromFileImpl(absl::string_view input_filename, T* proto) {
  const auto file_or_err =
      llvm::MemoryBuffer::getFileOrSTDIN(StringViewToRef(input_filename));
  if (std::error_code error = file_or_err.getError()) {
    return errors::InvalidArgument(
        "Could not open input file ",
        string(input_filename.data(), input_filename.size()).c_str());
  }

  const auto& input_file = *file_or_err;

    auto module_or = tensorflow::SavedModelSignatureDefsToMlirImportLite(
        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;
    }

absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> ImportFlatbufferOrMlir(
    const std::string& input_filename, bool input_mlir,
    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(

// are used, and will fail for protobuf::MessageLite protos.
Status LoadProtoFromFile(absl::string_view input_filename,
                         protobuf::Message* proto);
Status LoadProtoFromFile(absl::string_view input_filename,
                         protobuf::MessageLite* proto);

}  // namespace tensorflow

  llvm::cl::ParseCommandLineOptions(argc, argv, "MLIR TFLite runner\n");

  auto file_or_err = llvm::MemoryBuffer::getFileOrSTDIN(input_filename.c_str());
  if (std::error_code error = file_or_err.getError()) {
    LOG(ERROR) << argv[0] << ": could not open input file '" << input_filename
               << "': " << error.message() << "\n";
    return 1;
  }

  // Load the MLIR module.
  mlir::DialectRegistry registry;

// Setting prune_unused_nodes to true, would prune unreachable nodes if
// output_arrays is specified.
absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> LoadFromGraphdefOrMlirSource(
    const std::string& input_filename, bool input_mlir,
    bool use_splatted_constant, const std::vector<std::string>& extra_tf_opdefs,
    const GraphImportConfig& specs, absl::string_view debug_info_file,

  }
  pass_manager.clear();

  return mlir::success();
}

}  // namespace

absl::StatusOr<OwningOpRef<ModuleOp>> LoadFromGraphdefOrMlirSource(
    const std::string& input_filename, bool input_mlir,
    bool use_splatted_constant, const std::vector<std::string>& extra_tf_opdefs,
    const GraphImportConfig& specs, absl::string_view debug_info_file,

namespace mlir {
namespace TFL {
namespace tac {

// Import the file as mlir module, the input maybe flatbuffer or mlir file.
absl::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> ImportFlatbufferOrMlir(
    const std::string& input_filename, bool input_mlir,
    bool experimental_prune_unreachable_nodes_unconditionally,
    llvm::SourceMgr* source_mgr, mlir::MLIRContext* context);

// Export the module to file, can be either mlir or flatbuffer.

	}
}

func processFile(inputFileName string, privateKey []byte) {
	// 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"

    def "determines name and extension from file name #inputFileName with version #version"() {
        when:
        def artifactFile = new ArtifactFile(new File(inputFileName), version)

        then:
        artifactFile.name == name
        artifactFile.extension == extension
        artifactFile.classifier == null

        where:
        inputFileName       | name              | extension | version