static const char kOldBridgeMlirFilteredFailure[] =
    "kOldBridgeMlirFilteredFailure";
static const char kOldBridgeWithFallbackModeFailure[] =
    "kOldBridgeWithFallbackModeFailure";
static const char kOldBridgeMlirFilteredSuccess[] =
    "kOldBridgeMlirFilteredSuccess";
static const char kOldBridgeWithFallbackModeSuccess[] =
    "kOldBridgeWithFallbackModeSuccess";

          return absl::OkStatus();
        });

    // Register the corresponding fake op kernel.
    const char* node_name = opdef.name().c_str();
    const char* op_name = opdef.name().c_str();
    const char* device_name = "CPU";
    static auto fake_compute_func = [](void* kernel, TF_OpKernelContext* ctx) {
    };

    TF_KernelBuilder* builder =

  absl::Status AddString(const char* str, size_t len);

  // Fill content into a buffer and returns the number of bytes stored.
  // The function allocates space for the buffer but does NOT take ownership.
  int WriteToBuffer(char** buffer);

 private:
  // Data buffer to store contents of strings, not including headers.
  std::vector<char> data_;
  // Offset of the starting index of each string in data buffer.

#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <vector>

#include "absl/status/status.h"

namespace mlir::TFL {

absl::Status MiniDynamicBuffer::AddString(const char* str, size_t len) {
  // If `data_.size() + len` is greater than `SIZE_MAX` then the left hand side
  // will overflow to something less than max_length_. After checking `len <=

    public val BOOLEAN: KaType
        get() = boolean

    public abstract val char: KaType

    @Deprecated("Use 'char' instead.", replaceWith = ReplaceWith("char"))
    public val CHAR: KaType
        get() = char

    public abstract val string: KaType

    @Deprecated("Use 'string' instead.", replaceWith = ReplaceWith("string"))

    {tsl::monitoring::Buckets::Exponential(1, 1.5, 45)});

// There were no MLIR ops so the old bridge was called successfully.
constexpr char kOldBridgeNoMlirSuccess[] = "kOldBridgeNoMlirSuccess";
// There were no MLIR ops so the old bridge was called but it failed.
constexpr char kOldBridgeNoMlirFailure[] = "kOldBridgeNoMlirFailure";

namespace {

// Time the execution of kernels (in CPU cycles). Meant to be used as RAII.

#include "tsl/platform/protobuf.h"

namespace mlir {
using tsl::Status;
using tsl::StatusOr;

static constexpr char kMlirToGraphCompilationCheckName[] =
    "mlir-to-graph-compilation-check";
// Use CPU arbitrarily in order to check that a graph compiles at all
static constexpr char kArbitraryDeviceName[] = "XLA_CPU_JIT";

namespace {
inline absl::string_view StringRefToView(llvm::StringRef ref) {

    override val float: KaType by cachedBuiltin(builtinTypes.floatType)
    override val double: KaType by cachedBuiltin(builtinTypes.doubleType)

    override val char: KaType by cachedBuiltin(builtinTypes.charType)
    override val boolean: KaType by cachedBuiltin(builtinTypes.booleanType)
    override val string: KaType by cachedBuiltin(builtinTypes.stringType)

      tflite::TensorType_INT8, {}, /*disable_per_channel=*/false,
      /*fully_quantize=*/true, output_buffer);
}

}  // namespace
}  // namespace mlir

int main(int argc, char** argv) {
  llvm::InitLLVM y(argc, argv);
  llvm::cl::ParseCommandLineOptions(argc, argv);
  auto file_or_err = llvm::MemoryBuffer::getFileOrSTDIN(inputFileName.c_str());
  if (std::error_code error = file_or_err.getError()) {

  flatbuffers::FlatBufferBuilder output_builder;
  ASSERT_TRUE(SparsifyModel(input_model, &output_builder).ok());
  auto output_fbm = tflite::FlatBufferModel::BuildFromBuffer(
      reinterpret_cast<const char*>(output_builder.GetCurrentBufferPointer()),
      output_builder.GetSize());
  tflite::ModelT output_model;
  output_fbm->GetModel()->UnPackTo(&output_model);

  // Extract output metadata