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

	// "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"

	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

	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

	VPSHUFBITQMB Y14, Y2, K3, K6                       // 62d26d2b8ff6
	VPSHUFBITQMB Y8, Y2, K3, K6                        // 62d26d2b8ff0
	VPSHUFBITQMB Y20, Y2, K3, K6                       // 62b26d2b8ff4
	VPSHUFBITQMB -17(BP), Y2, K3, K6                   // 62f26d2b8fb5efffffff
	VPSHUFBITQMB -15(R14)(R15*8), Y2, K3, K6           // 62926d2b8fb4fef1ffffff

	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

	}

	duration := ts2.Sub(ts1)
	y1, m1, d1 := ts1.Date()
	y2, m2, d2 := ts2.Date()

	switch timePart {
	case timePartYear:
		dy := int64(y2 - y1)
		if m2 > m1 || (m2 == m1 && d2 >= d1) {
			return FromInt(dy), nil
		}
		return FromInt(dy - 1), nil
	case timePartMonth:
		m1 += time.Month(12 * y1)
		m2 += time.Month(12 * y2)

		return FromInt(int64(m2 - m1)), nil
	case timePartDay:

	tmp2.Add(tmp2, numer)
	if big.CmpInt(tmp2, denom) >= 0 {
		return -1
	}
	return tmp1.Int64()
}

func nextTerm(k int64) {
	y2 := k*2 + 1
	accum.Add(accum, tmp1.Lsh(numer, 1))
	accum.Mul(accum, tmp1.SetInt64(y2))
	numer.Mul(numer, tmp1.SetInt64(k))
	denom.Mul(denom, tmp1.SetInt64(y2))
}

func eliminateDigit(d int64) {
	accum.Sub(accum, tmp1.Mul(denom, tmp1.SetInt64(d)))
	accum.Mul(accum, ten)
	numer.Mul(numer, ten)