absl::StatusOr<std::vector<std::string>> ListDirectory(
    absl::string_view directory);

template <class MessageT>
absl::StatusOr<MessageT> ReadBinaryProto(const std::string& binary_file_path) {
  MessageT message;
  TF_RETURN_IF_ERROR(
      tsl::ReadBinaryProto(tsl::Env::Default(), binary_file_path, &message));
  return message;
}

}  // namespace stablehlo::quantization::io

    TF_ASSIGN_OR_RETURN(
        bool saved_model_pb_exists,
        internal::FileExists(Env::Default(), saved_model_pb_path));
    if (saved_model_pb_exists) {
      Status result = ReadBinaryProto(Env::Default(), saved_model_pb_path,
                                      saved_model_proto);
      if (result.ok()) {
        metrics::SavedModelReadCount(
            saved_model::GetWriteVersion(*saved_model_proto))

  AddInputFromArray<int64_t>(TensorShape({0}), {});

  TF_CHECK_OK(RunOpKernel());
  kernel_.reset();

  CalibrationStatisticsMap statistics_map;
  TF_CHECK_OK(
      ReadBinaryProto(Env::Default(), output_file_path, &statistics_map));
  ASSERT_THAT(statistics_map.statistics(), SizeIs(1));
  ASSERT_THAT(statistics_map.statistics(), ElementsAre(Key("1")));

    absl::string_view export_dir, std::string pb_file) {
  // Version of the code that produced the fingerprint.
  const int kFingerprintProducer = 1;

  SavedModel saved_model;
  TF_RETURN_IF_ERROR(ReadBinaryProto(Env::Default(), pb_file, &saved_model));

  // Create a copy of `metagraph` which will be used and mutated for fingerprint
  // computation.
  FingerprintDef fingerprint_def;

  const string saved_model_pbtxt_path =
      io::JoinPath(path, kSavedModelFilenamePbTxt);
  if (Env::Default()->FileExists(saved_model_pb_path).ok()) {
    TF_RETURN_IF_ERROR(ReadBinaryProto(Env::Default(), saved_model_pb_path,
                                       &tf_package.saved_model_proto_));
  } else if (Env::Default()->FileExists(saved_model_pbtxt_path).ok()) {

  CalibrationStatisticsFlatMap statistics_map;
  for (const std::string& statistics_file : statistics_files) {
    TF_ASSIGN_OR_RETURN(
        const auto single_map,
        io::ReadBinaryProto<CalibrationStatisticsMap>(
            tsl::io::JoinPath(calibration_data_dir, statistics_file)));
    statistics_map.insert(single_map.statistics().begin(),
                          single_map.statistics().end());
  }

  TF_ASSIGN_OR_RETURN(
      bool saved_model_pb_exists,
      internal::FileExists(Env::Default(), saved_model_pb_path));
  if (saved_model_pb_exists) {
    absl::Status result =
        ReadBinaryProto(Env::Default(), saved_model_pb_path, saved_model_proto);
    if (result.ok()) {
      metrics::SavedModelReadCount(
          saved_model::GetWriteVersion(*saved_model_proto))
          .IncrementBy(1);
    }

}

static Status ReadProtoFile(const string& fname, protobuf::Message* proto) {
  if (absl::EndsWith(fname, ".pbtxt")) {
    return ReadTextProto(Env::Default(), fname, proto);
  } else {
    return ReadBinaryProto(Env::Default(), fname, proto);
  }
}

static absl::once_flag targets_init;

static void InitializeTargets() {
  // Initialize all LLVM targets so we can cross compile.
#if TF_LLVM_AARCH32_AVAILABLE