max_value = tf_op.getMaxAttr();
    return true;  // Successfully matched and fetched.
  }
};

template <class TFFakeQuantOp>
struct FetchConstantMinMaxInputs {
  using AttrType = DenseFPElementsAttr;
  bool operator()(TFFakeQuantOp tf_op, AttrType &min_value,
                  AttrType &max_value) const {
    Value min = tf_op.getMin(), max = tf_op.getMax();
    if (auto min_id = min.getDefiningOp<TF::IdentityOp>()) {

                                                              values->end());
      state.attributes.set(
          const_op.getValueAttrName(),
          DenseFPElementsAttr::get(
              mlir::dyn_cast<ShapedType>(const_op.getValue().getType())
                  .clone(rewriter.getBF16Type()),
              bfloat16_values));
    }

}

// Checks whether the value of a constant equals the given float, regardless
// of the tensor dimension.
bool FloatValueEquals(const Attribute& attr, const double value) {
  const auto fp_attr = mlir::dyn_cast_or_null<DenseFPElementsAttr>(attr);
  if (!fp_attr) return false;

  if (fp_attr.isSplat()) {
    return fp_attr.getSplatValue<APFloat>().isExactlyValue(value);
  }

    if (operands.size() != 1) return failure();
    int weight_operand_idx = *operands.begin();

    Operation* weight_op = op.getOperand(weight_operand_idx).getDefiningOp();
    DenseFPElementsAttr attr;
    if (!matchPattern(weight_op->getResult(0), m_Constant(&attr))) {
      return failure();
    }

    // Get new shape.
    llvm::ArrayRef<int64_t> cur_shape = attr.getType().getShape();

    return HasValidWeightOnlyPtqMethod(method.weight_only_ptq(), rank);
  }

  void rewrite(Operation* op, PatternRewriter& rewriter) const override {
    Operation* quantizable_op = *op->getUsers().begin();
    DenseFPElementsAttr attr;
    matchPattern(op->getResult(0), m_Constant(&attr));

    Method method = GetQuantizationMethodOrDefault(quantizable_op);
    const WeightOnlyPtq& weight_only_ptq = method.weight_only_ptq();

      // This is i8 values disguised as f32 (due to the upcast trick). Simply
      // cast them to i8.
      ElementsAttr filter_value = filter_constant_op.getValue();
      filter_i8_value_attr =
          mlir::cast<DenseFPElementsAttr>(filter_value)
              .mapValues(rewriter.getI8Type(), [](const APFloat& val) -> APInt {
                APSInt convertedInt(/*BitWidth=*/8, /*isUnsigned=*/false);
                bool ignored;

        legacy_float_scale_(legacy_float_scale) {}
  LogicalResult matchAndRewrite(QuantizeOp op,
                                PatternRewriter& rewriter) const override {
    DenseFPElementsAttr attr;
    if (matchPattern(op.getInput(), m_Constant(&attr))) {
      auto qtype = op.getQtypeAttr();
      Attribute quantized_attr;
      if (legacy_float_scale_) {

  return val;
}

// Returns true if the attr is a float attribute and be equal to value.
static bool FloatValueEquals(const Attribute &attr, double value) {
  auto fp_attr = mlir::dyn_cast_or_null<DenseFPElementsAttr>(attr);
  if (fp_attr == nullptr) return false;

  if (fp_attr.isSplat()) {
    return fp_attr.getSplatValue<APFloat>().isExactlyValue(value);
  }

  Value new_value = builder.create<TF::MulOp>(loc, float_value, multiplier);
  auto new_value_type = mlir::cast<TensorType>(new_value.getType());

  // Get multiplier value in double.
  DenseFPElementsAttr multiplier_attr;
  if (!matchPattern(multiplier, m_Constant(&multiplier_attr)) ||
      mlir::cast<ShapedType>(multiplier_attr.getType()).getRank() > 1) {
    return {};
  }
  std::vector<double> multiplier_values;

    // operand if necessary.
    DenseFPElementsAttr cst;
    if (!matchPattern(binary_op->getOperand(1), m_Constant(&cst)))
      return failure();
    if (cst.getNumElements() != 1) return failure();
    APFloat cst_value = *cst.value_begin<APFloat>();

    // Affine op.
    Value filter = fc_op.getFilter();
    Value bias = fc_op.getBias();
    DenseFPElementsAttr filter_cst, bias_cst;