// What remains is to choose e.
// Let m = 2^e/c + delta, 0 <= delta < 1
//   ⎣x * (2^e/c + delta) / 2^e⎦
//   ⎣x / c + x * delta / 2^e⎦
// We must have x * delta / 2^e < 1/c so that this
// additional term never rounds differently than ⎣x / c⎦ does.
// Rearranging,
//   2^e > x * delta * c
// x can be at most 2^n-1 and delta can be at most 1.
// So it is sufficient to have 2^e >= 2^n*c.
// So we'll choose e = n + s, with s = ⎡log2(c)⎤.

    }
    int div = p / q;
    int rem = p - q * div; // equal to p % q

    if (rem == 0) {
      return div;
    }

    /*
     * Normal Java division rounds towards 0, consistently with RoundingMode.DOWN. We just have to
     * deal with the cases where rounding towards 0 is wrong, which typically depends on the sign of
     * p / q.
     *

	ROUND2(R4,R5,R6,R7,10,0xd62f105d, 5);
	ROUND2(R7,R4,R5,R6,15, 0x2441453, 9);
	ROUND2(R6,R7,R4,R5, 4,0xd8a1e681,14);
	ROUND2(R5,R6,R7,R4, 9,0xe7d3fbc8,20);
	ROUND2(R4,R5,R6,R7,14,0x21e1cde6, 5);
	ROUND2(R7,R4,R5,R6, 3,0xc33707d6, 9);
	ROUND2(R6,R7,R4,R5, 8,0xf4d50d87,14);
	ROUND2(R5,R6,R7,R4,13,0x455a14ed,20);
	ROUND2(R4,R5,R6,R7, 2,0xa9e3e905, 5);
	ROUND2(R7,R4,R5,R6, 7,0xfcefa3f8, 9);
	ROUND2(R6,R7,R4,R5,12,0x676f02d9,14);

    }
    int div = p / q;
    int rem = p - q * div; // equal to p % q

    if (rem == 0) {
      return div;
    }

    /*
     * Normal Java division rounds towards 0, consistently with RoundingMode.DOWN. We just have to
     * deal with the cases where rounding towards 0 is wrong, which typically depends on the sign of
     * p / q.
     *

	ROUND2(R4,R5,R22,R3,M15,0xd8a1e681,14);
	ROUND2(R3,R4,R5,R22,M04,0xe7d3fbc8,20);
	ROUND2(R22,R3,R4,R5,M09,0x21e1cde6, 5);
	ROUND2(R5,R22,R3,R4,M14,0xc33707d6, 9);
	ROUND2(R4,R5,R22,R3,M03,0xf4d50d87,14);
	ROUND2(R3,R4,R5,R22,M08,0x455a14ed,20);
	ROUND2(R22,R3,R4,R5,M13,0xa9e3e905, 5);
	ROUND2(R5,R22,R3,R4,M02,0xfcefa3f8, 9);
	ROUND2(R4,R5,R22,R3,M07,0x676f02d9,14);
	ROUND2(R3,R4,R5,R22,M12,0x8d2a4c8a,20);

	ROUND4(R4,R5,R2,R3, 5,0xab9423a7,15);
	ROUND4(R3,R4,R5,R2,12,0xfc93a039,21);
	ROUND4(R2,R3,R4,R5, 3,0x655b59c3, 6);
	ROUND4(R5,R2,R3,R4,10,0x8f0ccc92,10);
	ROUND4(R4,R5,R2,R3, 1,0xffeff47d,15);
	ROUND4(R3,R4,R5,R2, 8,0x85845dd1,21);
	ROUND4(R2,R3,R4,R5,15,0x6fa87e4f, 6);
	ROUND4(R5,R2,R3,R4, 6,0xfe2ce6e0,10);
	ROUND4(R4,R5,R2,R3,13,0xa3014314,15);
	ROUND4(R3,R4,R5,R2, 4,0x4e0811a1,21);
	ROUND4(R2,R3,R4,R5,11,0xf7537e82, 6);

	ROUND1(DX,AX,BX,CX, 6,0x4787c62a,12);
	ROUND1(CX,DX,AX,BX, 7,0xa8304613,17);
	ROUND1(BX,CX,DX,AX, 8,0xfd469501,22);
	ROUND1(AX,BX,CX,DX, 9,0x698098d8, 7);
	ROUND1(DX,AX,BX,CX,10,0x8b44f7af,12);
	ROUND1(CX,DX,AX,BX,11,0xffff5bb1,17);
	ROUND1(BX,CX,DX,AX,12,0x895cd7be,22);
	ROUND1(AX,BX,CX,DX,13,0x6b901122, 7);
	ROUND1(DX,AX,BX,CX,14,0xfd987193,12);
	ROUND1(CX,DX,AX,BX,15,0xa679438e,17);
	ROUND1(BX,CX,DX,AX, 1,0x49b40821,22);

	// to 1<<63 that the division rounds up to 1.0, and we've guaranteed
	// that the result is always less than 1.0.
	//
	// We tried to fix this by mapping 1.0 back to 0.0, but since float64
	// values near 0 are much denser than near 1, mapping 1 to 0 caused
	// a theoretically significant overshoot in the probability of returning 0.
	// Instead of that, if we round up to 1, just try again.

	ROUND4(AX,BX,CX,DX, 3,0x655b59c3, 6);
	ROUND4(DX,AX,BX,CX,10,0x8f0ccc92,10);
	ROUND4(CX,DX,AX,BX, 1,0xffeff47d,15);
	ROUND4(BX,CX,DX,AX, 8,0x85845dd1,21);
	ROUND4(AX,BX,CX,DX,15,0x6fa87e4f, 6);
	ROUND4(DX,AX,BX,CX, 6,0xfe2ce6e0,10);
	ROUND4(CX,DX,AX,BX,13,0xa3014314,15);
	ROUND4(BX,CX,DX,AX, 4,0x4e0811a1,21);
	ROUND4(AX,BX,CX,DX,11,0xf7537e82, 6);
	ROUND4(DX,AX,BX,CX, 2,0xbd3af235,10);
	ROUND4(CX,DX,AX,BX, 9,0x2ad7d2bb,15);

}

// Round returns the result of rounding d to the nearest multiple of m.
// The rounding behavior for halfway values is to round away from zero.
// If the result exceeds the maximum (or minimum)
// value that can be stored in a [Duration],
// Round returns the maximum (or minimum) duration.
// If m <= 0, Round returns d unchanged.
func (d Duration) Round(m Duration) Duration {
	if m <= 0 {
		return d