const bool is_weight_buffer = is_constant && (bitwidth == 8);

  int64_t storage_min =
      QuantizedType::getDefaultMinimumForInteger(is_signed, bitwidth) +
      static_cast<int>(is_weight_buffer);
  int64_t storage_max =
      QuantizedType::getDefaultMaximumForInteger(is_signed, bitwidth);
  uint32_t flags =
      is_signed ? mlir::quant::QuantizationFlags::FlagValue::Signed : 0;

#include "mlir/IR/OpDefinition.h"  // from @llvm-project
#include "mlir/IR/Operation.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project

using QuantizedType = mlir::quant::QuantizedType;
using UniformQuantizedType = mlir::quant::UniformQuantizedType;

namespace mlir {
namespace quant {
// Verifies that the op satisfies the same operands and results scales

    if (is_per_channel_quantization) {
      quant_type = mlir::dyn_cast<quant::QuantizedType>(
          quant::GetUniformQuantizedPerAxisTypeForWeight(
              attr, quant_dim,
              /*symmetric=*/true, bit_width, is_signed, is_narrow_range,
              is_legacy_float));
    } else {
      quant_type = mlir::dyn_cast<quant::QuantizedType>(
          quant::GetUniformQuantizedTypeForWeight(

        }
        if (type.getElementType().isa<QuantizedType>()) {
          has_quantized_types = true;
        }
      }
    }
    for (Value output : call_op.getOutput()) {
      if (auto type = output.getType().dyn_cast<TensorType>()) {
        if (type.getElementType().isa<FloatType>()) {
          return false;
        }
        if (type.getElementType().isa<QuantizedType>()) {
          has_quantized_types = true;

  func.return
}

// Checks that TF quantized attrs are lowered to the corert types
// CHECK-LABEL: func @quantized_types
func.func @quantized_types(%arg0: tensor<!tf_type.resource<tensor<1x3x!tf_type.quint8>>>,
                      %arg1: tensor<!tf_type.resource<tensor<1x3x!tf_type.quint16>>>,

message StaticRangePtq {
  // Operand index -> QuantizedType mapping. Operands that are not specified
  // here will be quantized with best effort.
  map<int32, QuantizedType> input_quantized_types = 1;
}

message WeightOnlyPtq {
  // Operand index -> QuantizedType mapping. Operands that are not specified
  // here will be quantized with best effort.
  map<int32, QuantizedType> input_quantized_types = 1;
}

      // adjustments and should be kept. Instead, move dequantize op before the
      // requantize op to remove the unnecessary requantize op.
      if (const QuantizedType qtype =
              QuantizedType::getQuantizedElementType(q.getArg().getType())) {
        rewriter.setInsertionPoint(op);
        rewriter.replaceOpWithNewOp<quantfork::DequantizeCastOp>(
            op, op.getResult().getType(), q.getArg());

    passthrough_op->replaceAllUsesWith(dequantize_op);

    // Set the input type of the passthrough op and pull it up.
    Type new_output_type;
    if (mlir::isa<quant::QuantizedType>(input_element_type)) {
      new_output_type = QuantizedType::getQuantizedElementType(
                            dequantize_op.getInput().getType())
                            .castFromExpressedType(output_type);
    } else {

    EXPECT_TRUE(isa<quant::QuantizedType>(state.params));
  }
  for (const auto& result : quantization_driver.GetResultStates()) {
    Operation* op = result.first.first;
    const int res_index = result.first.second;
    const QuantState state =
        quantization_driver.GetResultQuantState(op, res_index);
    EXPECT_TRUE(isa<quant::QuantizedType>(state.params));
  }
}

        op->getLoc(), *output_type, op.getInput());
    rewriter.replaceOpWithNewOp<mhlo::BitcastConvertOp>(
        op,
        output_type->clone(
            mlir::dyn_cast<quant::QuantizedType>(output_type->getElementType())
                .getStorageType()),
        result);

    return success();
  }
};

// UniformDequantizeOp takes TF quantized types as input which would have been