auto _o = std::unique_ptr<CustomQuantizationT>(new CustomQuantizationT());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;

  // Load input model
  auto input_fbm = tflite::FlatBufferModel::BuildFromFile(
      "tensorflow/lite/testdata/sparse_tensor.bin");
  tflite::ModelT input_model;
  input_fbm->GetModel()->UnPackTo(&input_model);

  // Populate input metadata
  auto model_metadata_buffer = std::make_unique<tflite::BufferT>();
  model_metadata_buffer->data =
      std::vector<uint8_t>(expected_value.begin(), expected_value.end());

//
// This helper is useful as UnPackTo requires the input to not have any existing
// state so directly calling UnPackTo could lead to memory leaks if the model
// already had some state. Instead, the returned object from here can be used to
// overwrite existing model.
ModelT UnPackFlatBufferModel(const Model& flatbuffer_model) {
  ModelT model;
  flatbuffer_model.UnPackTo(&model);
  return model;
}

  if (!model) {
    PyErr_Format(PyExc_ValueError, "Invalid model");
    return nullptr;
  }
  auto tflite_model = std::make_unique<tflite::ModelT>();
  model->GetModel()->UnPackTo(tflite_model.get(), nullptr);

  const tflite::TensorType inference_tensor_type =
      FromTocoDataTypeToTflitToTensorType(inference_type);
  const tflite::TensorType input_type =

  return op_name.lower();
}

std::unique_ptr<tflite::ModelT> CreateMutableModelFromFile(
    const tflite::Model* input_model) {
  auto copied_model = std::make_unique<tflite::ModelT>();
  input_model->UnPackTo(copied_model.get(), nullptr);
  return copied_model;
}
}  // namespace

// TODO(b/214314076): Support MLIR model as an input for the C++ dynamic range
// quantization API
TfLiteStatus QuantizeWeights(

constexpr bool kUseUpdatedHybridSchemeDefault = true;

std::unique_ptr<ModelT> CreateMutableModelFromFile(const Model* input_model) {
  auto copied_model = std::make_unique<ModelT>();
  input_model->UnPackTo(copied_model.get(), nullptr);
  return copied_model;
}

std::unique_ptr<FlatBufferModel> ReadTestModel() {
  auto model_path = tensorflow::io::JoinPath(
      *g_test_model_dir, internal::kConvModelWith0Plus10Weights);