             let r = uh - q * vn1 // Remainder, less than vn1
             let p = q * vn0
             // q is often already correct, but sometimes the approximation overshoots by at most 2.
-            // The code that follows checks for this while being careful not to need double-digit operations.
+            // The code that follows checks for this while being careful to only perform single-digit operations.
             if q.high == 0 && p <= (r << halfShift) | ul { return q }
             if (r + vn1).high != 0 { return q - 1 }
-            if (q - 1).high == 0 && (p - vn0) <= ((r + vn1) << halfShift) | ul { return q - 1 }
-            assert((r + 2 * vn1).high != 0 || p - 2 * vn0 <= (r + 2 * vn1) << halfShift | ul)
+            if (q - 1).high == 0 && (p - vn0) <= Digit(high: r + vn1, low: ul) { return q - 1 }
+            assert((r + 2 * vn1).high != 0 || p - 2 * vn0 <= Digit(high: r + 2 * vn1, low: ul))
             return q - 2
         }
         /// Divide 3 half-digits by 2 half-digits to get a half-digit quotient and a full-digit remainder.
         /// - Requires: uh < vn && ul.high == 0 && vn.rank = width(Digit)
         func divmod(uh: Digit, _ ul: Digit, _ v: Digit) -> (div: Digit, mod: Digit) {
             let q = quotient(uh, ul, v)
-            // Note that `uh << halfShift` will shift off a couple of bits, and `q * v` and the
+            // Note that `uh.low` masks off a couple of bits, and `q * v` and the
             // subtraction are likely to overflow. Despite this, the end result (remainder) will
             // still be correct and it will fit inside a single (full) Digit.
-            let r = ((uh << halfShift) | ul) &- q &* v
+            let r = Digit(high: uh.low, low: ul) &- q &* v
             assert(r < v)
             return (q, r)
         }

        let (q1, un21) = divmod(un32, un1, vn)
        let (q0, rn) = divmod(un21, un0, vn)

        // Undo normalization of remainder and combine the two halves of the quotient.
        let mod = rn >> z
        let div = Digit(high: q1, low: q0)
        return (div, mod)

        let z = (2 * halfShift - w) // number of leading zeroes in v
        let vn = v << z

        let un32 = (z == 0 ? u1 : (u1 << z) | (u0 >> w)) // No bits are lost
        let un10 = u0 << z
        let (un1, un0) = un10.split

