result.size());

  return kTfLiteOk;
}

TfLiteStatus QuantizeWeights(flatbuffers::FlatBufferBuilder* builder,
                             const tflite::Model* input_model,
                             int64_t weights_min_num_elements,
                             bool use_hybrid_evaluation) {
  return QuantizeWeights(
      builder, input_model,
      /*inference_type=*/tflite::TensorType_INT8,

// Overloading methods to support old quantizer versions API
TfLiteStatus QuantizeWeights(flatbuffers::FlatBufferBuilder* builder,
                             const tflite::Model* input_model,
                             int64_t weights_min_num_elements,
                             bool use_hybrid_evaluation = true);

TfLiteStatus QuantizeWeights(flatbuffers::FlatBufferBuilder* builder,

namespace {
tensorflow::string* g_test_model_dir = nullptr;
}  // namespace

namespace tflite {
namespace optimize {
namespace {

using mlir::lite::BufferType;
using mlir::lite::CustomOpMap;
using mlir::lite::QuantizeWeights;
constexpr bool kUseUpdatedHybridSchemeDefault = true;

std::unique_ptr<ModelT> CreateMutableModelFromFile(const Model* input_model) {
  auto copied_model = std::make_unique<ModelT>();

    default:
      return absl::InvalidArgumentError("Quantized type not supported");
      break;
  }

  bool use_updated_hybrid_scheme = !quant_specs.disable_per_channel;
  if (::tflite::optimize::QuantizeWeights(
          &q_builder, input_model, quantized_type, use_updated_hybrid_scheme,
          ::tflite::optimize::QuantizerType::OLD_QUANTIZER) != kTfLiteOk) {
    return absl::InvalidArgumentError(