test32()
	test64()
}

func test32() {
	var a uint32 = 0x11111111
	var want, got uint32
	if want, got = a+c32a, add32a(a); got != want {
		panic(fmt.Sprintf("add32a(%x) = %x, want %x", a, got, want))
	}
	if want, got = a+c32s, add32s(a); got != want {
		panic(fmt.Sprintf("add32s(%x) = %x, want %x", a, got, want))
	}
	if want, got = a-c32a, sub32a(a); got != want {

	VMALF  X1, YDIG, ADD2H, ADD4
	VMALHF X0, YDIG, ADD1H, ADD3H // ADD1H Free->ADD3H
	VMALHF X1, YDIG, ADD2H, ADD4H // ADD2H Free->ADD4H , YDIG Free->ZER

	VZERO ZER
	VL    32(CPOOL), SEL1
	VPERM ZER, ADD1, SEL1, RED3 // [d0 0 0 d0]

	VSLDB $12, ADD2, ADD1, T0 // ADD1 Free->T0
	VSLDB $12, T2, ADD2, T1   // ADD2 Free->T1, T2 Free

	VACCQ  T0, RED1, CAR1
	VAQ    T0, RED1, T0
	VACCCQ T1, RED2, CAR1, T2

// (x-C) to (x+(-C)).

// x + (C + z) -> C + (x + z)
(Add64 (Add64 i:(Const64 <t>) z) x) && (z.Op != OpConst64 && x.Op != OpConst64) => (Add64 i (Add64 <t> z x))
(Add32 (Add32 i:(Const32 <t>) z) x) && (z.Op != OpConst32 && x.Op != OpConst32) => (Add32 i (Add32 <t> z x))
(Add16 (Add16 i:(Const16 <t>) z) x) && (z.Op != OpConst16 && x.Op != OpConst16) => (Add16 i (Add16 <t> z x))

(Mul64 x y) =>
	(Int64Make
		(Add32 <typ.UInt32>
			(Mul32 <typ.UInt32> (Int64Lo x) (Int64Hi y))
			(Add32 <typ.UInt32>
				(Mul32 <typ.UInt32> (Int64Hi x) (Int64Lo y))
				(Select0 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y)))))
		(Select1 <typ.UInt32> (Mul32uhilo (Int64Lo x) (Int64Lo y))))

(And64 x y) =>
	(Int64Make
		(And32 <typ.UInt32> (Int64Hi x) (Int64Hi y))
		(And32 <typ.UInt32> (Int64Lo x) (Int64Lo y)))

	VMULT_ADD(X0, YDIG, T0, ONE, ADD1, ADD1H)
	VMULT_ADD(X1, YDIG, T1, ONE, ADD2, ADD2H)

	VSPLTW $0, Y0, YDIG // VREPF

	//	VMALF  X0, YDIG, ADD1H, ADD3
	//	VMALF  X1, YDIG, ADD2H, ADD4
	//	VMALHF X0, YDIG, ADD1H, ADD3H // ADD1H Free->ADD3H
	//	VMALHF X1, YDIG, ADD2H, ADD4H // ADD2H Free->ADD4H , YDIG Free->ZER
	VMULT_ADD(X0, YDIG, ADD1H, ONE, ADD3, ADD3H)
	VMULT_ADD(X1, YDIG, ADD2H, ONE, ADD4, ADD4H)

  // Just to introduce an extra use for %cst.
  %1 = "tf.AddV2"(%feature_group_count, %feature_group_count) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i32>
  %2 = "tf.AddV2"(%lhs_dilation, %lhs_dilation) {device = ""} : (tensor<3xi32>, tensor<3xi32>) -> tensor<3xi32>
  %3 = "tf.AddV2"(%rhs_dilation, %rhs_dilation) {device = ""} : (tensor<3xi32>, tensor<3xi32>) -> tensor<3xi32>

// CHECK: %[[relu:.*]] = "tf.Relu"(%[[dequant1]]
// CHECK: %[[clamped:.*]] = "tf.Minimum"(%[[relu]]

// CHECK: %[[rescale1:.*]] = "tf.Mul"(%[[cast]]
// CHECK: %[[add2:.*]] = "tf.AddV2"(%[[rescale1]]
// CHECK: %[[maximum2:.*]] = "tf.Maximum"(%[[add2]]
// CHECK: %[[minimum2:.*]] = "tf.Minimum"(%[[maximum2]]
// CHECK: %[[round2:.*]] = "tf.Round"(%[[minimum2]]

  // CHECK-NEXT: %[[ADD2:.*]] = "tf.AddV2"(%[[BARG0]], %[[DELTA]])
  %add2 = "tf.AddV2"(%arg0, %constant) : (tensor<i32>, tensor<i32>) -> tensor<i32>
  // CHECK-NEXT: return %[[ADD2]], %[[ADD1]]
  %id = "tf.Identity"(%arg2) : (tensor<*x!tf_type.resource<tensor<f32>>>) -> tensor<*x!tf_type.resource<tensor<f32>>>

  Output in = ops::Placeholder(on_gpu.WithOpName("in"), DT_FLOAT);
  Output c = ops::Const(on_gpu.WithOpName("const"), 1.0f, {});
  Output add1 = ops::AddV2(on_gpu.WithOpName("add1"), in, c);
  Output add2 = ops::AddV2(on_gpu.WithOpName("add2"), add1, c);

  std::unique_ptr<Graph> result;
  TF_ASSERT_OK(CloneConstantsForBetterClustering(root, &result));

  OutputTensor add1_operand;
  TF_ASSERT_OK(

  // CHECK-NEXT: %[[ADDN2:.*]] = "tf.AddN"(%[[ADDN]], %[[ZEROS_LIKE]]) : (tensor<10xf32>, tensor<10xf32>) -> tensor<10xf32>
  %addn2 = "tf.AddN"(%addn, %zeros-like) : (tensor<!tf_type.variant<tensor<f32>>>, tensor<!tf_type.variant<tensor<f32>>>) -> tensor<!tf_type.variant<tensor<f32>>>
  %stack = "tf.TensorListStack"(%addn2, %elem_shape) : (tensor<!tf_type.variant<tensor<f32>>>, tensor<0xi32>) -> tensor<10xf32>