             }
         }
         
-        @inlinable
-        var hashValue: Int {
+        @inlinable @inline(__always) // This should always be inlined into Data.hash(into:).
+        func hash(into hasher: inout Hasher) {
             switch self {
             case .empty:
-                return Int(bitPattern: CFHashBytes(nil, 0))
+                hasher.combine(Int(bitPattern: CFHashBytes(nil, 0)))
             case .inline(let inline):
-                return inline.hashValue
+                inline.hash(into: &hasher)
             case .slice(let slice):
-                return slice.hashValue
-            case .large(let slice):
-                return slice.hashValue
+                slice.hash(into: &hasher)
+            case .large(let large):
+                large.hash(into: &hasher)
             }
         }
     }

            }
        }

        @inlinable
        var hashValue: Int {
            let count: Int = numericCast(length)
            return Swift.withUnsafeBytes(of: bytes) { (rawBuffer) -> Int in
                return Int(bitPattern: CFHashBytes(UnsafeMutablePointer(mutating: rawBuffer.baseAddress?.assumingMemoryBound(to: UInt8.self)), count))
            }
        }
    }


            storage.copyBytes(to: pointer, from: range)
        }

        @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)
            }
        }
    }
