*
   * @since 20.0
   */
  public static final class LinearTransformationBuilder {

    private final double x1;
    private final double y1;

    private LinearTransformationBuilder(double x1, double y1) {
      this.x1 = x1;
      this.y1 = y1;
    }

    /**
     * Finish building an instance which also maps {@code x = x2} to {@code y = y2}. These values

	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

		}
		return v, err
	}

	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

    assertThat(transformation.transform(x1)).isWithin(ALLOWED_ERROR).of(y1);
    assertThat(transformation.transform(x1 + xDelta)).isWithin(ALLOWED_ERROR).of(y1 + yDelta);
    assertThat(transformation.inverse().transform(y1)).isWithin(ALLOWED_ERROR).of(x1);
    assertThat(transformation.inverse().transform(y1 + yDelta))
        .isWithin(ALLOWED_ERROR)
        .of(x1 + xDelta);

const3, hlp0, hlp0 ADC $0, acc4 ADDS t1, acc1, acc1 ADCS y0, acc2, acc2 ADCS acc0, acc3, acc3 ADC $0, hlp0, acc0 // y[1] * x MUL y1, x0, t0 ADDS t0, acc1 UMULH y1, x0, t1 MUL y1, x1, t0 ADCS t0, acc2 UMULH y1, x1, hlp0 MUL y1, x2, t0 ADCS t0, acc3 UMULH y1, x2, y0 MUL y1, x3, t0 ADCS t0, acc4 UMULH y1, x3, y1 ADC $0, ZR, acc5 ADDS t1, acc2 ADCS hlp0, acc3 ADCS y0, acc4 ADC y1, acc5 // Second reduction step MUL acc1, hlp1, hlp0 MUL const0, hlp1, t0 ADDS t0, acc1, acc1 UMULH const0, hlp0, t1 MUL const1,...

const3, hlp0, hlp0 ADC $0, acc4 ADDS t1, acc1, acc1 ADCS y0, acc2, acc2 ADCS acc0, acc3, acc3 ADC $0, hlp0, acc0 // y[1] * x MUL y1, x0, t0 ADDS t0, acc1 UMULH y1, x0, t1 MUL y1, x1, t0 ADCS t0, acc2 UMULH y1, x1, hlp0 MUL y1, x2, t0 ADCS t0, acc3 UMULH y1, x2, y0 MUL y1, x3, t0 ADCS t0, acc4 UMULH y1, x3, y1 ADC $0, ZR, acc5 ADDS t1, acc2 ADCS hlp0, acc3 ADCS y0, acc4 ADC y1, acc5 // Second reduction step MUL acc1, hlp1, hlp0 MUL const0, hlp1, t0 ADDS t0, acc1, acc1 UMULH const0, hlp0, t1 MUL const1,...

    /*
     * For an explanation of the basic principle behind this check, see
     * https://stackoverflow.com/a/35754308/28465
     *
     * In that explanation's notation, our `overlap` check would be `x1 < y2 && y1 < x2`. We've
     * flipped one part of the check so that we're using "less than" in both cases (rather than a
     * mix of "less than" and "greater than"). We've also switched to "strictly less than" rather