} : (tensor<2x2x!tf_type.qint8>, tensor<2xf32>, tensor<2xi32>) -> tensor<2x2xf32>
  func.return %2 : tensor<2x2xf32>
}

//===----------------------------------------------------------------------===//
// tf.UniformQuantizedDot legalization
//===----------------------------------------------------------------------===//

// -----

// CHECK-LABEL: func @uniform_quantized_dot

                         %filter_scale : tensor<*xf32>, %filter_zp : tensor<*xi32>, %out_scale : tensor<*xf32>, %out_zp : tensor<*xi32>) -> tensor<*x!tf_type.qint32> {
    %dot_out = "tf.UniformQuantizedDot"(%input, %filter,
                                %input_scale, %input_zp, %filter_scale, %filter_zp, %out_scale, %out_zp) {
        Tin = "tfdtype$DT_QINT8",
        Tout = "tfdtype$DT_QINT32",

  %quant_input = "tf.Cast"(%input) {} : (tensor<8x9xi8>) -> tensor<8x9x!tf_type.qint8>
  %quant_filter = "tf.Cast"(%filter) {} : (tensor<9x10xi8>) -> tensor<9x10x!tf_type.qint8>
  %0 = "tf.UniformQuantizedDot"(
    %quant_input, %quant_filter, %input_scale, %input_zp, %filter_scale,
    %filter_zp, %accum_scale, %accum_zp
  ) {
    Tin = "tfdtype$DT_QINT8", Tout = "tfdtype$DT_QINT32", attr_map = "",

  %weight_scales: tensor<f32>, %weight_zps: tensor<i32>,
  %output_scales: tensor<f32>, %output_zps: tensor<i32>) -> () {
  // expected-error @below {{'tf.UniformQuantizedDot' op quantization_axis is -1, scales must have 0 rank.}}
  %1 = "tf.UniformQuantizedDot"(
    %input, %weight,
    %input_scales, %input_zps,
    %weight_scales, %weight_zps,
    %output_scales, %output_zps) {
      lhs_quantization_axis = -1 : i64,

      "TruncatedNormal",
      "UniformDequantize",
      "UniformQuantize",
      "UniformQuantizedAdd",
      "UniformQuantizedClipByValue",
      "UniformQuantizedConvolution",
      "UniformQuantizedDot",
      "UniformRequantize",
      "Unique",
      "UniqueV2",
      "UpperBound",
      "UnsortedSegmentMax",
      "UnsortedSegmentMin",
      "UnsortedSegmentProd",

          )
      )
    elif target_opset == quant_opts_pb2.UNIFORM_QUANTIZED:
      self.assertTrue(
          self._contains_op(
              output_graphdef,
              'UniformQuantizedDot',
              node_name='sample/matmul.*',
          )
      )

    new_outputs = converted_model.signatures['serving_default'](
        input_tensor=ops.convert_to_tensor(input_data)
    )

  TF_DerivedOperandTypeAttr Trhs = TF_DerivedOperandTypeAttr<1>;
  TF_DerivedResultTypeAttr Tout = TF_DerivedResultTypeAttr<0>;

  let hasVerifier = 1;
}

def TF_UniformQuantizedDotOp : TF_Op<"UniformQuantizedDot", [Pure]> {
  let summary = [{
Perform quantized dot of quantized Tensor `lhs` and quantized Tensor `rhs` to make quantized `output`.
  }];

  let description = [{