DeviceTarget::DeviceTarget(MLIRContext* ctx) : ctx_(ctx) {
  f32_ = FloatType::getF32(ctx_);
  i8_ = IntegerType::get(ctx_, k8Bits);
  i8_min_ = QuantizedType::getDefaultMinimumForInteger(kSigned, k8Bits);
  i8_max_ = QuantizedType::getDefaultMaximumForInteger(kSigned, k8Bits);
  i32_ = IntegerType::get(ctx_, k32Bits);
  i32_min_ = QuantizedType::getDefaultMinimumForInteger(kSigned, k32Bits);

  int64_t chunk_size =
      std::accumulate(std::next(shape.begin(), quantization_dim_ + 1),
                      shape.end(), 1, std::multiplies<int64_t>());
  Type new_element_type =
      IntegerType::get(attr.getContext(), storage_bit_width_);
  return attr.mapValues(new_element_type, [&](const APFloat &old) {
    int chunk_index = flatten_index / chunk_size;
    flatten_index++;

      builder_.getF32Type(),
      /*scale=*/1.0,
      /*zeroPoint=*/0, /*storageTypeMin=*/-128, /*storageTypeMax=*/127);
  EXPECT_TRUE(IsSupportedByTfliteQuantizeOrDequantizeOps(
      dyn_cast_or_null<IntegerType>(qi8_type.getStorageType())));
}

TEST_F(IsSupportedByTfliteQuantizeOrDequantizeOpsTest, StorageTypeI16Succeeds) {
  auto qi16_type = quant::UniformQuantizedType::get(

  auto etype = op.getType().getElementType();
  if (etype.isa<FloatType>()) {
    return FoldDivOpInternal<APFloat>(op, rewriter);
  }
  if (etype.isa<IntegerType>()) {
    return FoldDivOpInternal<APInt>(op, rewriter);
  }
  return failure();
}
}  // namespace

void PopulateFolderPatterns(RewritePatternSet& patternSet) {
  patternSet.add(FoldDivOp);
}

// Determines whether the storage type of a quantized type is supported by
// `tfl.quantize` or `tfl.dequantize` ops. ui8, i8 and i16 are supported.
bool IsSupportedByTfliteQuantizeOrDequantizeOps(IntegerType storage_type);

// Returns true if a type is quantized tensor type.
bool IsQuantizedTensorType(Type type);

// Returns true if all operands and results are quantized.
bool IsOpFullyQuantized(Operation* op);

  Attribute identity_attr;
  if (auto ty = mlir::dyn_cast<FloatType>(element_ty)) {
    identity_attr = FloatAttr::get(ty, static_cast<double>(identity));
  } else if (auto ty = mlir::dyn_cast<IntegerType>(element_ty)) {
    identity_attr = IntegerAttr::get(ty, static_cast<int64_t>(identity));
  } else {
    return {};
  }

  // Fold: Op(Operand, Identity) -> Operand.

                                       Location conversion_loc) const final {
    if (!input.getType().isa<IntegerType>() ||
        !result_type.isa<IntegerType>()) {
      return nullptr;
    }
    auto input_itype = input.getType().cast<IntegerType>();
    auto result_itype = result_type.cast<IntegerType>();
    if (input_itype.getWidth() == result_itype.getWidth()) return nullptr;

          op->getResult(index).getType().template cast<ShapedType>();
      if (!result_type.getElementType().template isa<FloatType>()) return {};
      Builder builder(op->getContext());
      const IntegerType storage_type = builder.getIntegerType(BitWidth);
      const double scale = static_cast<double>(ScaleMantissa) *
                           std::pow(10.0, static_cast<double>(ScaleExp));

    } else {
      return tensorflow::Status(absl::StatusCode::kInvalidArgument,
                                "Unsupported type");
    }
  } else if (auto itype = mlir::dyn_cast<mlir::IntegerType>(element_type)) {
    if (element_type.isSignedInteger()) {
      switch (itype.getWidth()) {
        case 8:
          return DenseElementsAttr::get<int8_t>(shaped_type,

      QuantizedMultipliers* output_multipliers, QuantizedRanges* output_ranges);

  // A set of parameters are required to build the signatures.
  FloatType f32_;
  IntegerType i8_, i32_;
  int64_t i8_min_, i8_max_, i32_min_, i32_max_;
  quant::AnyQuantizedType any_, qi8_, qi8n_, qi32_;

 private:
  // Maps the kernel names to all the available kernels.