     /// The unsigned integer representation of string exceeds
     /// 128 bits.
     case StringInputOverflow
-    /// A condition that shouldn't ever happen. Hax0r!
-    case Inconceivable
 }
 // MARK: Data Type
 /// A 128-bit unsigned integer value type.

    /// data type does not exist, so it has to fall back to an IntMax
    /// representation which lacks half of the storage space when end
    /// is less than the value of self.
    public func distanceTo(end: UInt128) -> UInt128.Distance {
        if end >= self {
            return UInt128.Distance(end - self)
        }
        return Int(end) &- Int(self)
    }
}
// MARK: - IntegerLiteralConvertible
extension UInt128: IntegerLiteralConvertible {
    public init(integerLiteral value: IntegerLiteralType) {
        self.init()
        self.value.lowerBits = UInt64(value)
    }
    public init(_builtinIntegerLiteral value: _MaxBuiltinIntegerType) {
        self.init()
        self.value.lowerBits = UInt64(_builtinIntegerLiteral: value)
    }
}
// MARK: - StringLiteralConvertible
extension UInt128: StringLiteralConvertible {
    public init(stringLiteral value: String) {
        self.init()
        do {
            try self = UInt128.fromUnparsedString(value)
        } catch { return }
    }
    // MARK: UnicodeScalarLiteralConvertible
    public init(unicodeScalarLiteral value: String)  {
        self.init(stringLiteral: value)
    }
    // MARK: ExtendedGraphemeClusterLiteralConvertible
    public init(extendedGraphemeClusterLiteral value: String) {
        self.init(stringLiteral: value)
    }
}

        var byteShift: UInt128 = 120
        // Loop through each of our 16 bytes.
        for index in 0 ..< bytes.count {
            if byteMask <= 0xff << 56 {
                // The bottom 8 bytes will get masked and shifted to opposing byte.
                bytes[index] = (self & byteMask) << byteShift
                // Don't decrease the shifter on the bottom half's last byte, as this
                // down shift will become the up shift during the next for loop run.
                if byteMask != 0xff << 56 {
                    byteShift -= 16
                }
                byteMask <<= 8
            } else if byteMask >= (0xff << 63) << 1 {
                // The top 8 bytes will get masked and shifted to opposing byte.
                bytes[index] = (self & byteMask) >> byteShift
                byteMask <<= 8
