public final class NBKPrimeSieve {

    /// Creates a new instance and sieves the first page.
    public init(cache: Cache = .KiB(32), wheel: Wheel = .x07, culls: Culls = .x11, capacity: Int? = nil)

    /// The highest value checked for primality.
    public var limit: UInt { get }
    
    /// A list of all primes from zero through `limit`.
    public var elements: [UInt] { get }

    /// Sieves the next page of numbers.
    public func increment()
}

+ struct NBKStaticBigInt
- struct NBKTwinHeaded<Base>

init?(words: some RandomAccessCollection<UInt>)
init?(words: some RandomAccessCollection<UInt>, isSigned: Bool)

func bitshift[ed][direction](major:minor:) // from bitshift[ed][direction](words:bits:)
func bitrotate[d][direction](major:minor:) // from bitrotate[d][direction](words:bits:)

+ enum   NBKEndianness
+ struct NBKTwinHeaded<Base>
+ struct NBKChunkedInt<Base, Element>
- struct NBKLittleEndianOrdered<Base>

for uint32 in NBKChunkedInt(source, isSigned: false, count: nil, as: UInt32.self) { ... }

[1, 2, 3, 4] == Array(NBKChunkedInt(([0x0201, 0x0403] as [Int16]),            as: UInt8.self))
[2, 1, 4, 3] == Array(NBKChunkedInt(([0x0201, 0x0403] as [Int16]).reversed(), as: UInt8.self).reversed())
[3, 4, 1, 2] == Array(NBKChunkedInt(([0x0201, 0x0403] as [Int16]).reversed(), as: UInt8.self))
[4, 3, 2, 1] == Array(NBKChunkedInt(([0x0201, 0x0403] as [Int16]),            as: UInt8.self).reversed())

[0x0201, 0x0403] == Array(NBKChunkedInt(([1, 2, 3, 4] as [UInt8]),            as: Int16.self))
[0x0102, 0x0304] == Array(NBKChunkedInt(([1, 2, 3, 4] as [UInt8]).reversed(), as: Int16.self).reversed())
[0x0403, 0x0201] == Array(NBKChunkedInt(([1, 2, 3, 4] as [UInt8]),            as: Int16.self).reversed())
[0x0304, 0x0102] == Array(NBKChunkedInt(([1, 2, 3, 4] as [UInt8]).reversed(), as: Int16.self))

NBKTwinHeaded(elements, reversed: Bool.random())

- NBKDoubleWidth.uninitialized(_:)

.iOS(.v14),          // from 16.4
.macCatalyst(.v14),  // from 16.4
.macOS(.v11),        // from 13.3
.tvOS(.v14),         // from 16.4
.watchOS(.v7),       // from  9.4

/// A collection that iterates forwards or backwards depending on the platform.
///
/// It iterates front-to-back on little-endian platforms, and back-to-front otherwise.
///
/// ```swift
/// let value = Int256.uninitialized { words in
///     for index in words.indices {
///         words.base.initializeElement(at: words.baseIndex(index), to: UInt.zero)
///     }
/// }
/// ```
///
public struct NBKLittleEndianOrdered<Base>: RandomAccessCollection where Base: RandomAccessCollection { }

+ literal: Digit        (by default)
+ literal: StaticString (by default)
- literal: StaticBigInt (by default)

- public static func uninitialized(_ body: (inout Self) -> Void) -> Self {
+ public static func uninitialized(_ body: (NBKLittleEndianOrdered<UnsafeMutableBufferPointer<UInt>>) -> Void) -> Self

bitWidth >= 1

var nonzeroBitCount:     Int { get }
var leadingZeroBitCount: Int { get }
var mostSignificantBit: Bool { get }

func subtractingReportingOverflow(_ other: Self) -> PVO<Self>
mutating func subtractReportingOverflow(_ other: Self) -> Bool

func subtractingReportingOverflow(_ other: Digit) -> PVO<Self>
mutating func subtractReportingOverflow(_ other: Digit) -> Bool