%weight_scale : tensor<*xf32>, %weight_zp : tensor<*xi32>) -> tensor<*xf32>
      attributes {tf_quant.quantized_ops = ["Conv2D"]} {

    %out = "tf.UniformQuantizedConvolutionHybrid"(%input, %weight,
                           %weight_scale, %weight_zp) {
        Tlhs = "tfdtype$DT_FLOAT",
        Trhs = "tfdtype$DT_QINT8",
        Tout = "tfdtype$DT_FLOAT",
        window_strides = [1, 1],

// CHECK: return %[[quantize_1]], %[[quantize_2]]

// CHECK-LABEL: func private @quantized_conv2d_fn_0
// CHECK:      %[[CONV2D_0:.*]] = "tf.UniformQuantizedConvolutionHybrid"
// CHECK-SAME: batch_group_count = 1 : i64
// CHECK-SAME: dimension_numbers = "\10\03\1A\02\01\02 \02(\032\02\00\01@\03J\02\01\02"
// CHECK-SAME: explicit_padding = []
// CHECK-SAME: feature_group_count = 1 : i64

  func.return %0 : tensor<?xf32>
}

//===----------------------------------------------------------------------===//
// tf.UniformQuantizedConvolutionHybrid legalization
//===----------------------------------------------------------------------===//

// -----

// CHECK-LABEL: func @uniform_quantized_convolution_hybrid

  %filter_zp = "tf.Const"() { value = dense<0> : tensor<i32> } : () -> tensor<i32>
  %quant_filter = "tf.Cast"(%filter) {} : (tensor<3x3x10x20xi8>) -> tensor<3x3x10x20x!tf_type.qint8>
  %0 = "tf.UniformQuantizedConvolutionHybrid"(
    %input, %quant_filter, %filter_scale, %filter_zp
  ) {
    Tin = "tfdtype$DT_QINT8", Tout = "tfdtype$DT_FLOAT",
    attr_map = "", batch_group_count = 1 : i64,

  // expected-error @below {{'tf.UniformQuantizedConvolutionHybrid' op quantization_axis is -1, scales must have 0 rank.}}
  %0 = "tf.UniformQuantizedConvolutionHybrid"(%lhs, %rhs, %rhs_scales, %rhs_zps) {
    window_strides = [1, 2],
    padding = "VALID",
    explicit_padding = [],
    lhs_dilation = [1, 1],

          self._contains_op(
              output_graphdef, 'UniformQuantizedConvolutionHybrid'
          )
      )
      self.assertFalse(self._contains_op(output_graphdef, 'Conv2D'))
      if enable_per_channel_quantization:
        self.assertTrue(
            self._contains_op(
                output_graphdef,
                'UniformQuantizedConvolutionHybrid',
                'rhs_quantization_axis',

  TF_DerivedResultTypeAttr Tout = TF_DerivedResultTypeAttr<0>;

  let hasVerifier = 1;
}

def TF_UniformQuantizedConvolutionHybridOp : TF_Op<"UniformQuantizedConvolutionHybrid", [Pure]> {
  let summary = [{
Perform hybrid quantized convolution of float Tensor `lhs` and quantized Tensor `rhs`.
  }];

  let description = [{