return %1 : tensor<1x3x!quant.uniform<i8:f32, 1.000000e-03:-3>>
  }
}

// -----

// Merge fusion with dequantize for no activation case.

module attributes {tf_saved_model.semantics} {
  // CHECK-LABEL: func.func private @merge_no_act_fusion
  func.func private @merge_no_act_fusion(%arg0: tensor<1x4xf32>) -> tensor<1x3xf32> {

def TFR_TFRQuantActRangeOp : TFR_Op<"quant_act_range", [Pure]> {
  let description = [{
   The `quant_act_range` returns the a pair of integers to indicate the fixed
   range for the fused activation `act` with the quantization defined by the
   `scale` and `zero point`. Currently, the allowed activations are
   `NONE`, `RELU`, `RELU6` and `RELU_N1_TO_1`.

    Example:

    ```mlir

// Ternary ops patterns.
//===----------------------------------------------------------------------===//
// Multi-pattern consisting of matching stand-alone convolution op followed by
// activation op.
multiclass FuseActFnIntoConvOpPat<Op ActFnOp, ConstantStrAttr ActFnAttr> {
  def FuseActivationFuncWithConv#ActFnOp#ActFnAttr : Pat<
    (ActFnOp (TFL_Conv2DOp:$conv_out $input, $filter, $bias, $h_factor,

// dynamic batch dimension is properly quantized.

// Note that this checks for identical condition as
// quantize_conv_with_bias_dynamic_fn, omitting stablehlo.maximum.
// This is because activation clipping which includes 0.0f can be simply
// omitted from the graph as the lifted function's out_scale and out_zp are
// already calculated based on the clipped distribution.

    // optimizations in the pipeline.
    METHOD_NO_QUANTIZE = 1;

    // Static range quantization. Quantized tensor values' ranges are statically
    // determined. The activation and weight are quantized to INT8 while bias is
    // quantized to INT32.
    METHOD_STATIC_RANGE_INT8 = 2;

    // Dynamic range quantization. Quantized tensor values' ranges are

    %mul = "tf.Mul"(%cast, %scale_prod) : (tensor<*xf32>, tensor<*xf32>) -> tensor<*xf32>
    func.return %mul : tensor<*xf32>
  }

  // TODO(b/263199401): Support quantization options for activation quantization for DRQ
  // Note: following function supports per-tensor, asymmetric, non_narrow_range.
  func.func private @internal_calculate_quant_params(%input : tensor<*xf32>) -> (tensor<1xf32>, tensor<1xi32>) {

  QuantizationSpecs specs = 4;

  // Configures the quantization debugger.
  DebuggerConfig debugger_config = 5;

  // Defines calibration options for quantization. This option is only used for
  // activation of static range quantization (SRQ). Quantization calibration
  // method is set to MIN_MAX by default.
  CalibrationOptions calibration_options = 6;

  // Path to file to save the quantization report, which is essentially a

  let cppNamespace = "::mlir::TFL";
}

def TFL_DimensionTypeAttr : EnumAttr<TFL_Dialect, TFL_DimensionType,
    "dimension_type_attr"> {
  let convertFromStorage = "$_self";
}

// Allowed activation function cases
// These should match the ActivationFunctionType enum in TFLite schema.
def TFL_AFEnum_None  : I32EnumAttrCase<"NONE", 0>;
def TFL_AFEnum_Relu  : I32EnumAttrCase<"RELU", 1>;

// CHECK: %[[QCONST_0:.+]] =  "tfl.pseudo_qconst"()
// CHECK: "tfl.batch_matmul"(%[[ARG]], %[[QCONST_0]]) <{adj_x = false, adj_y = false}>

// -----

// Tests static range quantized dot_general with activation as RHS

*   Add `UnifiedGRU` as the new GRU implementation for tf2.0. Change the default
    recurrent activation function for GRU from `hard_sigmoid` to `sigmoid`, and
    `reset_after` to True in 2.0. Historically recurrent activation is
    `hard_sigmoid` since it is fast than 'sigmoid'. With new unified backend
    between CPU and GPU mode, since the CuDNN kernel is using sigmoid, we change