// the values with the TOCO quantizer.
TfLiteStatus QuantizeModel(
    absl::string_view model_buffer, const tflite::TensorType &input_type,
    const tflite::TensorType &output_type,
    const tflite::TensorType &inference_type,
    const std::unordered_set<std::string> &operator_names,
    bool disable_per_channel, bool fully_quantize, std::string &output_buffer,

  void Element(size_t i, flatbuffers::ElementaryType /*type*/,
               const flatbuffers::TypeTable* /*type_table*/,
               const uint8_t* /*val*/) override {
    if (i) s += ", ";
  }
};

void ToString(const std::string& serialized_model) {
  IndentedToStringVisitor visitor(/*delimiter=*/"\n", /*indent=*/"  ");
  IterateFlatBuffer(reinterpret_cast<const uint8_t*>(serialized_model.c_str()),

// TODO(krzysd) Handle function calls
StatusOr<Operation*> ConvertOp(
    const tflite::OperatorT& op, const std::vector<Value>& vals_map,
    const std::vector<mlir::TensorType>& intermediate_types,
    Value optional_arg_marker,
    const std::vector<std::unique_ptr<tflite::OperatorCodeT>>& op_codes,
    const std::vector<std::string>& func_names,
    const std::vector<std::unique_ptr<tflite::TensorT>>& tensors, Location loc,

}

Status PropagateShapes(Graph* graph,
                       const std::map<int, InferredShape>& arg_shapes,
                       const std::vector<BackEdgeHelper::BackEdge>& back_edges,
                       ShapeRefiner* shape_refiner) {
  std::map<const Node*, const Node*> merge_to_next_iteration;
  for (const auto& e : back_edges) {
    if (e.src->IsNextIteration() && e.dst->IsMerge()) {

absl::Status CalibrationComponent::ExportToSavedModel(
    ModuleOp module_op, absl::string_view calibration_data_dir,
    const bool force_regenerate_calibration_data,
    const absl::string_view dst_saved_model_path) {
  TF_ASSIGN_OR_RETURN(const std::string checkpoint_dir, GetLocalTmpFileName());

  // Clone ModuleOp and function aliases so changes in this pipeline won't

  };
  const auto subgraphs = {CreateSubgraphMetadata(
      fb_builder, fb_builder.CreateVector(ops.begin(), ops.size()))};

  const auto metadata = CreateRuntimeMetadata(
      fb_builder, hardwares,
      fb_builder.CreateVector(subgraphs.begin(), subgraphs.size()));
  fb_builder.Finish(metadata);

  return std::string(
      reinterpret_cast<const char*>(fb_builder.GetBufferPointer()),

 public:
  bool IsAlloc() const { return effects_.test(kAlloc); }
  bool IsFree() const { return effects_.test(kFree); }
  bool IsRead() const { return effects_.test(kRead); }
  bool IsWrite() const { return effects_.test(kWrite); }
  bool IsAllocOnly() const { return IsAlloc() && effects_.count() == 1; }
  bool IsReadOnly() const { return IsRead() && effects_.count() == 1; }
  ResourceId GetResourceId() const { return resource_id_; }

static const char kMlirWithFallbackModeSuccess[] =
    "kMlirWithFallbackModeSuccess";
static const char kMlirWithFallbackModeFailure[] =
    "kMlirWithFallbackModeFailure";
static const char kOldBridgeMlirFilteredFailure[] =
    "kOldBridgeMlirFilteredFailure";
static const char kOldBridgeWithFallbackModeFailure[] =
    "kOldBridgeWithFallbackModeFailure";
static const char kOldBridgeMlirFilteredSuccess[] =

    fprintf(stderr, "Read '%s' resulted in empty\n", name);
    return false;
  }
  *buf = s;
  return true;
}

bool ParseFile(flatbuffers::Parser *parser, const std::string &filename,
               const std::string &contents) {
  std::vector<const char *> include_directories;
  auto local_include_directory = flatbuffers::StripFileName(filename);
  include_directories.push_back(local_include_directory.c_str());

    (tensor<i32>, !mlrt.promise) -> !mlrt.async_handle

  // CHECK: [[const:%.*]]  = tf_mlrt.const
  %const = "tf.Const"() {__op_key = 1: i32, value = dense<2> : tensor<i32>} : () -> tensor<i32>

  // CHECK: [[b:%.*]] = tf_mlrt.await [[futures]]
  %b = "tf_mlrt.tf_await"(%future_b) : (!mlrt.future) ->tensor<i32>

  // CHECK: [[result:%.*]] = tf_mlrt.executeop([[b]], [[const]])
  // CHECK-SAME: AddV2