VADDPD (BX), Y15, Y2                    // c4e1055813 or c5855813
	VADDPD (R11), Y15, Y2                   // c4c1055813
	VADDPD Y2, Y15, Y2                      // c4e10558d2 or c58558d2
	VADDPD Y11, Y15, Y2                     // c4c10558d3
	VADDPD (BX), Y15, Y11                   // c46105581b or c505581b
	VADDPD (R11), Y15, Y11                  // c44105581b

	// "invalid VSIB address (missing vector index)"
	VPGATHERQQ Y2, (BP), Y1         // ERROR "invalid instruction"
	// AVX2GATHER mask/index/dest #UD cases.
	VPGATHERQQ Y2, (BP)(X2*2), Y2   // ERROR "mask, index, and destination registers should be distinct"
	VPGATHERQQ Y2, (BP)(X2*2), Y7   // ERROR "mask, index, and destination registers should be distinct"
	VPGATHERQQ Y2, (BP)(X7*2), Y2   // ERROR "mask, index, and destination registers should be distinct"

	VAESDECLAST Y31, Y27, Y2                           // 62922520dfd7 or 6292a520dfd7
	VAESDECLAST Y3, Y27, Y2                            // 62f22520dfd3 or 62f2a520dfd3
	VAESDECLAST Y14, Y27, Y2                           // 62d22520dfd6 or 62d2a520dfd6
	VAESDECLAST -17(BP)(SI*8), Y27, Y2                 // 62f22520df94f5efffffff or 62f2a520df94f5efffffff
	VAESDECLAST (R15), Y27, Y2                         // 62d22520df17 or 62d2a520df17

	VPGATHERQQ Y0, (SP)(Y1*1), Y2           // c4e2fd91140c
	VPGATHERQQ Y0, 16(SP)(Y1*1), Y2         // c4e2fd91540c10
	VPGATHERQQ Y0, 512(SP)(Y1*1), Y2        // c4e2fd91940c00020000
	VPGATHERQQ Y0, (R12)(Y1*1), Y2          // c4c2fd91140c
	VPGATHERQQ Y0, 16(R12)(Y1*1), Y2        // c4c2fd91540c10
	VPGATHERQQ Y0, 512(R12)(Y1*1), Y2       // c4c2fd91940c00020000
	VPGATHERQQ Y0, (BP)(Y1*1), Y2           // c4e2fd91540d00

	VPDPWSSD Y8, Y2, K3, Y14                           // 62526d2b52f0
	VPDPWSSD Y9, Y2, K3, Y14                           // 62526d2b52f1
	VPDPWSSD Y22, Y2, K3, Y14                          // 62326d2b52f6
	VPDPWSSD 15(R8)(R14*4), Y2, K3, Y14                // 62126d2b52b4b00f000000
	VPDPWSSD -7(CX)(DX*4), Y2, K3, Y14                 // 62726d2b52b491f9ffffff

	VPMADD52LUQ Y3, Y9, K1, Y2                         // 62f2b529b4d3
	VPMADD52LUQ Y2, Y9, K1, Y2                         // 62f2b529b4d2
	VPMADD52LUQ Y9, Y9, K1, Y2                         // 62d2b529b4d1
	VPMADD52LUQ 17(SP)(BP*1), Y9, K1, Y2               // 62f2b529b4942c11000000
	VPMADD52LUQ -7(CX)(DX*8), Y9, K1, Y2               // 62f2b529b494d1f9ffffff
	VPMADD52LUQ Y3, Y1, K1, Y2                         // 62f2f529b4d3

	VPERMI2B Y9, Y22, K2, Y2                           // 62d24d2275d1
	VPERMI2B 15(R8)(R14*1), Y22, K2, Y2                // 62924d227594300f000000
	VPERMI2B 15(R8)(R14*2), Y22, K2, Y2                // 62924d227594700f000000
	VPERMI2B Y18, Y20, K2, Y2                          // 62b25d2275d2
	VPERMI2B Y24, Y20, K2, Y2                          // 62925d2275d0

     * 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) {
      checkArgument(isFinite(x2) && isFinite(y2));

	VPCLMULQDQ $0, Y15, Y2, Y31                        // 62436d2844ff00 or 6243ed2844ff00
	VPCLMULQDQ $0, Y22, Y2, Y31                        // 62236d2844fe00 or 6223ed2844fe00
	VPCLMULQDQ $0, Y20, Y2, Y31                        // 62236d2844fc00 or 6223ed2844fc00
	VPCLMULQDQ $0, 99(R15)(R15*4), Y2, Y31             // 62036d2844bcbf6300000000 or 6203ed2844bcbf6300000000

	VANDPD -17(BP)(SI*1), Y3, K4, Y9                   // 6271e52c548c35efffffff
	VANDPD Y12, Y2, K4, Y9                             // 6251ed2c54cc
	VANDPD Y21, Y2, K4, Y9                             // 6231ed2c54cd
	VANDPD Y14, Y2, K4, Y9                             // 6251ed2c54ce
	VANDPD (BX), Y2, K4, Y9                            // 6271ed2c540b
	VANDPD -17(BP)(SI*1), Y2, K4, Y9                   // 6271ed2c548c35efffffff