             storage.copyBytes(to: pointer, from: range)
         }
 
-        @inlinable
-        var hashValue: Int {
-            let hashRange = startIndex..<Swift.min(startIndex + 80, endIndex)
-            return storage.withUnsafeBytes(in: hashRange) {
-                return Int(bitPattern: CFHashBytes(UnsafeMutablePointer(mutating: $0.baseAddress?.assumingMemoryBound(to: UInt8.self)), $0.count))
+        @inlinable @inline(__always) // This should always be inlined into _Representation.hash(into:).
+        func hash(into hasher: inout Hasher) {
+            hasher.combine(count)
+
+            // At most, hash the first 80 bytes of this data.
+            let range = startIndex ..< Swift.min(startIndex + 80, endIndex)
+            storage.withUnsafeBytes(in: range) {
+                hasher.combine(bytes: $0)
             }
         }
     }

            }
        }
        
        @inlinable
        var hashValue: Int {
            switch self {
            case .empty:
                return Int(bitPattern: CFHashBytes(nil, 0))
            case .inline(let inline):
                return inline.hashValue
            case .slice(let slice):
                return slice.hashValue
            case .large(let slice):
                return slice.hashValue
            }
        }
    }

    //
    
    /// The hash value for the data.
    @inline(never) // This is not inlinable as emission into clients could cause cross-module inconsistencies if they are not all recompiled together.
    public func hash(into hasher: inout Hasher) {
        _representation.hash(into: &hasher)
    }
    
    @inlinable
