// MixedPrecision-NEXT: %[[q:.*]] = "tfl.quantize"(%arg0)
// MixedPrecision-NEXT: %[[dq:.*]] = "tfl.dequantize"(%[[q]])
// MixedPrecision-NEXT: %[[q_0:.*]] = "tfl.quantize"(%arg1)
// MixedPrecision-NEXT: %[[dq_0:.*]] = "tfl.dequantize"(%[[q_0]])
// MixedPrecision-NEXT: %[[c:.*]] = "tfl.concatenation"(%[[dq]], %[[dq_0]])
// MixedPrecision-NEXT: %[[q_1:.*]] = "tfl.quantize"(%[[c]])

// RUN: tf-opt %s -tfl-prepare-quantize="quantize-signed=true post-training-quantize=true" -cse | FileCheck %s
// RUN: tf-opt %s -tfl-prepare-quantize="quantize-signed=true post-training-quantize=true legacy-float-scale=true" -cse| FileCheck --check-prefix=Legacy %s

// CHECK-LABEL: QuantizeLstmCellInput
func.func @QuantizeLstmCellInput(%arg0: tensor<1x28x28xf32>) -> tensor<1x28x20xf32> {
    %cst_2 = "tfl.no_value"() {value = unit} : () -> none

        /*value=*/filter_i8_value_attr);

    // Replace filter uses with uniform quantized filter.
    rewriter.replaceAllUsesWith(filter_op->getResult(0),
                                quantized_filter_constant_op.getResult());

    // Replace conv op with a new convolution op that has quantized output type.
    // Quantize -> Dequantize following r3.
    auto output_uniform_quantize_call_op = cast<func::CallOp>(

    lines.push_back(absl::StrFormat(
        "Number of quantized layers with quantized outputs: %d/%d",
        total_quantized_func_count - float_output_func_count,
        total_quantized_func_count));
    lines.push_back(absl::StrFormat("Number of quantize layers added: %d",
                                    quantize_func_count));
    lines.push_back(absl::StrFormat("Number of dequantize layers added: %d",

^bb0(%arg0: tensor<1x2xf32>):
  %cst_0 = arith.constant dense<[1, 0]> : tensor<2xi32>
  %0 = "tfl.quantize"(%arg0){qtype = tensor<1x2x!quant.uniform<u8:f32, 1.0>>}: (tensor<1x2xf32>) -> (tensor<1x2x!quant.uniform<u8:f32, 1.0>>)
  %1 = "tfl.dequantize"(%0): (tensor<1x2x!quant.uniform<u8:f32, 1.0>>) -> (tensor<1x2xf32>)
  %2 = "tf.Transpose"(%1, %cst_0): (tensor<1x2xf32>, tensor<2xi32>) -> tensor<2x1xf32>

              Eq(TensorType_INT8));

  // Verify FC bias should be int32 quantized.
  ASSERT_THAT(float_graph->tensors()->Get(float_op->inputs()->Get(2))->type(),
              Eq(TensorType_FLOAT32));
  EXPECT_THAT(subgraph->tensors[op->inputs[2]].get()->type,
              Eq(TensorType_INT32));

  // The output tensor of FC should be int8 quantized.
  ASSERT_THAT(float_graph->tensors()->Get(float_op->outputs()->Get(0))->type(),

// RUN: tf-quant-opt %s -split-input-file -quant-insert-quantized-functions -quant-quantize-composite-functions | FileCheck --check-prefix=TF %s
// RUN: tf-quant-opt %s -split-input-file -quant-insert-quantized-functions -quant-quantize-composite-functions='target-opset=XLA' | FileCheck --check-prefix=XLA %s

      return emitError(loc, type_or_err.status().ToString()),
             type_or_err.status();
    }
    auto type = std::move(type_or_err).value();

    if (op_name == "tfl.quantize") {
      // Special case for quantize: return type must also be in qtype attribute
      op_state.addAttribute("qtype", mlir::TypeAttr::get(type));
    } else if (op_name == "tfl.reshape" && op_state.operands.size() == 1) {

      .Default([](Type) {
        llvm_unreachable("QuantizedTypeIsUnsigned: not a quantized type");
        return false;
      });
}

// Return the half_range value that is used by DequantizeOp. half_range is used
// to offset the quantized representation before it gets scaled. In the case
// of negative quantize types, this offset is half the type's range.

foreach BinaryOp = [TFL_DivOp, TFL_MulOp]<Op> in
  defm : FuseMulOrDivWithConv2dOrDepthwiseConv2d<BinaryOp>;


// This pattern applies when the same quantize/dequantize have been used twice
// with the same scale. We want to remove the redundancy.
// TODO(fengliuai): move this to the sanity check of pre-quantize pass.
def eliminate_dq_q_pairs : Pat<
  (TFL_QuantizeOp (TFL_DequantizeOp $in), $qt),
  (replaceWithValue $in),