arg := a
			testFunVV(t, "addVV_novec", addVV_novec, arg)

			arg = argVV{a.z, a.y, a.x, a.c}
			testFunVV(t, "addVV_novec symmetric", addVV_novec, arg)

			arg = argVV{a.x, a.z, a.y, a.c}
			testFunVV(t, "subVV_novec", subVV_novec, arg)

			arg = argVV{a.y, a.z, a.x, a.c}
			testFunVV(t, "subVV_novec symmetric", subVV_novec, arg)
		}
	}

		"int ~int ~int ∅",
		"int string int string",
		"int ~string int ~string",
		"int myInt int myInt",
		"~int ~string ~int ~string",
		"~int myInt ~int ∅",

		// union is symmetric, but the result order isn't - repeat symmetric cases explicitly
		"𝓤 ∅ 𝓤 ∅",
		"int ∅ int ∅",
		"~int ∅ ~int ∅",
		"myInt ∅ myInt ∅",
		"int 𝓤 𝓤 ∅",
		"~int 𝓤 𝓤 ∅",
		"myInt 𝓤 𝓤 ∅",
		"~int int ~int ∅",

		"int ~int ~int ∅",
		"int string int string",
		"int ~string int ~string",
		"int myInt int myInt",
		"~int ~string ~int ~string",
		"~int myInt ~int ∅",

		// union is symmetric, but the result order isn't - repeat symmetric cases explicitly
		"𝓤 ∅ 𝓤 ∅",
		"int ∅ int ∅",
		"~int ∅ ~int ∅",
		"myInt ∅ myInt ∅",
		"int 𝓤 𝓤 ∅",
		"~int 𝓤 𝓤 ∅",
		"myInt 𝓤 𝓤 ∅",
		"~int int ~int ∅",

		{_M, 0, 1, 0, 1},
		{_M, 1, 1, 1, 1},
		{_M, _M, 0, _M - 1, 1},
		{_M, _M, 1, _M, 1},
	} {
		test("Add", Add, a.x, a.y, a.c, a.z, a.cout)
		test("Add symmetric", Add, a.y, a.x, a.c, a.z, a.cout)
		test("Sub", Sub, a.z, a.x, a.c, a.y, a.cout)
		test("Sub symmetric", Sub, a.z, a.y, a.c, a.x, a.cout)
		// The above code can't test intrinsic implementation, because the passed function is not called directly.

class PadOpsDefsTest(test_utils.OpsDefsTest, parameterized.TestCase):

  @parameterized.named_parameters(('ReflectMode', 'REFLECT'),
                                  ('SymmetricMode', 'SYMMETRIC'))
  def test_mirror_pad(self, mode):
    input_ = tf.constant([[1, 2, 3], [4, 5, 6]], dtype=tf.float32)
    paddings = tf.constant([[
        1,
        1,
    ], [2, 2]])
    kwargs = {
        'input': input_,

// HISTOGRAM-MSE-SYMMETRIC-CHECK-NEXT:  "tf.AddV2"
// HISTOGRAM-MSE-SYMMETRIC-CHECK-NEXT:  return

// HISTOGRAM-MSE-SYMMETRIC-CHECK: func @composite_conv2d_with_relu6_fn
// HISTOGRAM-MSE-SYMMETRIC-CHECK-NEXT:  "tf.Conv2D"
// HISTOGRAM-MSE-SYMMETRIC-CHECK-NEXT:  "tf.Relu6"
// HISTOGRAM-MSE-SYMMETRIC-CHECK-NEXT:  return


// -----

module {
  // CHECK-LABEL: func.func @main

// DecryptPKCS1v15SessionKey is designed for this situation and copies
// the decrypted, symmetric key (if well-formed) in constant-time over
// a buffer that contains a random key. Thus, if the RSA result isn't
// well-formed, the implementation uses a random key in constant time.
func ExampleDecryptPKCS1v15SessionKey() {
	// The hybrid scheme should use at least a 16-byte symmetric key. Here
	// we read the random key that will be used if the RSA decryption isn't

// the value range isn't straddling zero, an empty type is returned. The min/max
// are adjusted to be symmetric if `symmetric` flag is set to True. And
// `symmetric` can only be set to true when it is signed and narrow_range.
Type GetUniformQuantizedTypeForWeight(ElementsAttr attr, bool symmetric,
                                      unsigned num_bits, bool is_signed,
                                      bool narrow_range,

    // works for both this value and 0.0.
    if (single_value < 0.0) {
      mins[0] = single_value;
      maxs[0] = symmetric ? -single_value : 0.0;
    } else if (single_value > 0.0) {
      mins[0] = symmetric ? -single_value : 0.0;
      maxs[0] = single_value;
    } else {
      mins[0] = maxs[0] = single_value;
    }
    for (int i = 1; i < dim_size; ++i) {

flags.DEFINE_bool('gen_register_op', True,
                  'Generate register op cc file or tfr mlir file.')


@Composite(
    'NewMirrorPad',
    inputs=['input_: T', 'paddings: Tpaddings'],
    attrs=['mode: {"REFLECT", "SYMMETRIC"}'],
    derived_attrs=['T: type', 'Tpaddings: {int32, int64} = DT_INT32'],
    outputs=['output: T'])
def _composite_mirror_pad(input_, paddings, mode):
  shape = input_.shape.as_list()
  for i in range(len(shape)):