// PerTensor-DAG: %[[zp:.*]] = "tf.Const"() <{value = dense<0> : tensor<i32>}> : () -> tensor<i32>
// PerTensor: %[[out:.*]] = "tf.PartitionedCall"(%arg0, %[[q_w]], %[[scale]], %[[zp]]) <{config = "", config_proto = "", executor_type = "",
// PerTensor-SAME: f = @quantized_matmul_fn_0}> : (tensor<2x12xf32>, tensor<12x2xi8>, tensor<f32>, tensor<i32>) -> tensor<*xf32>

	VCVT_LT_F32_FXS16: "VCVT.LT.F32.FXS16",
	VCVT_GT_F32_FXS16: "VCVT.GT.F32.FXS16",
	VCVT_LE_F32_FXS16: "VCVT.LE.F32.FXS16",
	VCVT_F32_FXS16:    "VCVT.F32.FXS16",
	VCVT_ZZ_F32_FXS16: "VCVT.ZZ.F32.FXS16",
	VCVT_EQ_F32_FXS32: "VCVT.EQ.F32.FXS32",
	VCVT_NE_F32_FXS32: "VCVT.NE.F32.FXS32",
	VCVT_CS_F32_FXS32: "VCVT.CS.F32.FXS32",
	VCVT_CC_F32_FXS32: "VCVT.CC.F32.FXS32",
	VCVT_MI_F32_FXS32: "VCVT.MI.F32.FXS32",

  %arg0: tensor<1x10x!quant.uniform<i8:f32, 0.1:-128>>,
  %arg1: tensor<1x5xf32>) -> (tensor<1x10x!quant.uniform<i8:f32, 0.2:42>>, tensor<1x5xf32>) {
  %0 = "tf.MyRequantize"(%arg0) : (tensor<1x10x!quant.uniform<i8:f32, 0.1:-128>>) -> tensor<1x10x!quant.uniform<i8:f32, 0.2:42>>
  %1 = "tf.Intermediate"(%arg1) : (tensor<1x5xf32>) -> tensor<1x5xf32>
  func.return %0, %1 : tensor<1x10x!quant.uniform<i8:f32, 0.2:42>>, tensor<1x5xf32>

module {
func.func @main(%arg0 : tensor<5xf32>, %arg1 : tensor<f32>, %arg2 : tensor<f32>) -> tensor<5xf32> {
  %0 = "tf.ClipByValue"(%arg0, %arg1, %arg2) : (tensor<5xf32>, tensor<f32>, tensor<f32>) -> tensor<5xf32>
  func.return %0 : tensor<5xf32>
}

    %i8_max = "tf.Const"() {value = dense<127.0> : tensor<f32>} : () -> tensor<f32>
    %act_max =  "tf.Const"() {value = dense<6.0> : tensor<f32>} : () -> tensor<f32>
    %i8_act_max_0 = "tf.PartitionedCall"(%act_max, %out_scale, %out_zp) {
        config = "", config_proto = "", executor_type = "", f=@quantize_i8
      } : (tensor<f32>, tensor<*xf32>, tensor<*xi32>) -> tensor<*xi8>

    ^bb0(%arg23: tensor<f32>, %arg24: tensor<f32>):
      %1112 = "vhlo.add_v1" (%arg23, %arg24) : (tensor<f32>, tensor<f32>) -> tensor<f32>
      "vhlo.return_v1" (%1112) : (tensor<f32>) -> ()
    }) : (tensor<1x160x1xf32>, tensor<f32>) -> tensor<1x160x1xf32>
  return %0 : tensor<1x160x1xf32>
}

//CHECK:func.func private @reduce_window(%arg0: tensor<1x160x1xf32>, %arg1: tensor<f32>) -> tensor<1x160x1xf32> {

  // CHECK: {{.*}} = corert.executeop.seq({{.*}}) "tf.ReadVariableOp"({{.*}}) {dtype = f32} : 1
  // CHECK: {{.*}} = corert.executeop({{.*}}) "tf.MatMul"({{.*}}) {T = f32, transpose_a = false, transpose_b = false} : 1
  %0 = "tf.ReadVariableOp"(%arg1) {device = "/device:GPU:0", dtype = f32} : (tensor<!tf_type.resource<tensor<1x3xf32>>>) -> tensor<1x3xf32>

	chki64(int64(u64), cu64&0xffffffffffffffff-1<<64)
	//	chki64(int64(f32), 0)
	//	chki64(int64(f64), 0)


	chku8(uint8(i8), ci8&0xff)
	chku8(uint8(i16), ci16&0xff)
	chku8(uint8(i32), ci32&0xff)
	chku8(uint8(i64), ci64&0xff)
	chku8(uint8(u8), cu8&0xff)
	chku8(uint8(u16), cu16&0xff)
	chku8(uint8(u32), cu32&0xff)
	chku8(uint8(u64), cu64&0xff)
	//	chku8(uint8(f32), 0)
	//	chku8(uint8(f64), 0)

  func.func private @composite_dequantize_uniform(%arg0: tensor<*xi8>) -> tensor<*xf32> {
    %cst = "tf.Const"() {value = dense<0.0787401571> : tensor<f32>} : () -> tensor<f32>
    %0 = "tf.Cast"(%arg0) {Truncate = false} : (tensor<*xi8>) -> tensor<*xf32>
    %1 = "tf.Mul"(%0, %cst) : (tensor<*xf32>, tensor<f32>) -> tensor<*xf32>
    return %1 : tensor<*xf32>
  }

}

// CHECK-LABEL: func @not_propagate_last_op

  // CHECK: "tf.Iterator"
  // CHECK-SAME: output_shapes{{.*}}200x28x28x1{{.*}}200x10
  // CHECK-SAME: output_types = [f32, f32]
  // CHECK-SAME: shared_name = "_iterator1"
  %0 = "tf.AnonymousIteratorV3"() {output_shapes = [
    #tf_type.shape<200x28x28x1>,
    #tf_type.shape<200x10>], output_types = [f32, f32]} : () -> tensor<!tf_type.resource>
  // CHECK: "tf.Iterator"
  // CHECK-SAME: shared_name = "_iterator2"