VPDPWSSD X2, X2, K3, X18                           // 62e26d0b52d2
	VPDPWSSD X27, X2, K3, X18                          // 62826d0b52d3
	VPDPWSSD X26, X2, K3, X18                          // 62826d0b52d2
	VPDPWSSD (SI), X2, K3, X18                         // 62e26d0b5216
	VPDPWSSD 7(SI)(DI*2), X2, K3, X18                  // 62e26d0b52947e07000000
	VPDPWSSD X2, X24, K3, X18                          // 62e23d0352d2

	VRCP28SD X25, X14, K4, X2                          // 62928d0ccbd1
	VRCP28SD X11, X14, K4, X2                          // 62d28d0ccbd3
	VRCP28SD X17, X14, K4, X2                          // 62b28d0ccbd1
	VRCP28SD X25, X0, K4, X2                           // 6292fd0ccbd1
	VRCP28SD X11, X0, K4, X2                           // 62d2fd0ccbd3
	VRCP28SD X17, X0, K4, X2                           // 62b2fd0ccbd1

	VPERMB -7(DI)(R8*2), X20, K1, X23                  // 62a25d018dbc47f9ffffff
	VPERMB X26, X2, K1, X23                            // 62826d098dfa
	VPERMB X19, X2, K1, X23                            // 62a26d098dfb
	VPERMB X0, X2, K1, X23                             // 62e26d098df8
	VPERMB 7(SI)(DI*4), X2, K1, X23                    // 62e26d098dbcbe07000000
	VPERMB -7(DI)(R8*2), X2, K1, X23                   // 62a26d098dbc47f9ffffff

	VPGATHERDQ X2, 664(X2*8), X7    // ERROR "mask, index, and destination registers should be distinct"
	VPGATHERDQ X2, 664(X7*8), X2    // ERROR "mask, index, and destination registers should be distinct"
	VPGATHERDQ X7, 664(X2*8), X2    // ERROR "mask, index, and destination registers should be distinct"
	// Non-X0 for Yxr0 should produce an error

	f1 T1
	f2 T2
}

func NewPair[T1 interface{ M() }, T2 ~int](v1 T1, v2 T2) Pair[T1, T2] {
	return Pair[T1, T2]{f1: v1, f2: v2}
}

func (p Pair[X1, _]) First() X1 {
	return p.f1
}

func (p Pair[_, X2]) Second() X2 {
	return p.f2
}

// Deprecated: Use something else.
func Clone[S ~[]T, T any](s S) S {
	return append(S(nil), s...)

		// Test AVX512 suffixes.
		{"VADDPD.A X0, X1, X2", `unknown suffix "A"`},
		{"VADDPD.A.A X0, X1, X2", `unknown suffix "A"; duplicate suffix "A"`},
		{"VADDPD.A.A.A X0, X1, X2", `unknown suffix "A"; duplicate suffix "A"`},
		{"VADDPD.A.B X0, X1, X2", `unknown suffix "A"; unknown suffix "B"`},
		{"VADDPD.Z.A X0, X1, X2", `Z suffix should be the last; unknown suffix "A"`},
		{"VADDPD.Z.Z X0, X1, X2", `Z suffix should be the last; duplicate suffix "Z"`},

    x1.reset(x1_raw);
  }

  AbstractTensorHandlePtr x2;
  {
    AbstractTensorHandle* x2_raw = nullptr;
    status_ = TestScalarTensorHandle<float, TF_FLOAT>(
        immediate_execution_ctx_.get(), 1.0f, &x2_raw);
    ASSERT_EQ(errors::OK, status_.code()) << status_.message();
    x2.reset(x2_raw);
  }

  status_ = registry_.Register("IdentityN", IdentityNRegisterer);

     * must not both be identical to the values given in the first mapping. If only the {@code x}
     * values are identical, the transformation is vertical. If only the {@code y} values are
     * identical, the transformation is horizontal (i.e. the slope is zero).
     */
    public LinearTransformation and(double x2, double y2) {

	VPSHRDVW X2, X2, K7, X0                            // 62f2ed0f72c2
	VPSHRDVW X31, X2, K7, X0                           // 6292ed0f72c7
	VPSHRDVW X11, X2, K7, X0                           // 62d2ed0f72c3
	VPSHRDVW (AX), X2, K7, X0                          // 62f2ed0f7200
	VPSHRDVW 7(SI), X2, K7, X0                         // 62f2ed0f728607000000
	VPSHRDVW X2, X8, K7, X0                            // 62f2bd0f72c2

	ADDSD (R11), X2                         // f2410f5813
	ADDSD X2, X2                            // f20f58d2
	ADDSD X11, X2                           // f2410f58d3
	ADDSD (BX), X11                         // f2440f581b
	ADDSD (R11), X11                        // f2450f581b
	ADDSD X2, X11                           // f2440f58da
	ADDSD X11, X11                          // f2450f58db