         // The sequence is really not contiguous.
         // Copy as much as we can in one shot.
         let underestimatedCount = Swift.max(elements.underestimatedCount, 1)
-        _withStackOrHeapBuffer(underestimatedCount) { (buffer) in
+        __withStackOrHeapBuffer(underestimatedCount) { (buffer) in
             // In order to copy from the sequence, we have to bind the temporary buffer to `UInt8`.
             // This is safe since we're the only owners of the buffer and we copy out as raw memory below anyway.
             let capacity = buffer.pointee.capacity

    @inlinable // This is @inlinable as generic and reasonably small.
    public mutating func replaceSubrange<ByteCollection : Collection>(_ subrange: Range<Index>, with newElements: ByteCollection) where ByteCollection.Iterator.Element == Data.Iterator.Element {
        let totalCount = Int(newElements.count)
        _withStackOrHeapBuffer(totalCount) { conditionalBuffer in
            let buffer = UnsafeMutableBufferPointer(start: conditionalBuffer.pointee.memory.assumingMemoryBound(to: UInt8.self), count: totalCount)
            var (iterator, index) = newElements._copyContents(initializing: buffer)
            while let byte = iterator.next() {


            // Copy as much as we can in one shot from the sequence.
            let underestimatedCount = Swift.max(elements.underestimatedCount, 1)
            __withStackOrHeapBuffer(underestimatedCount) { (buffer) in
                // In order to copy from the sequence, we have to bind the buffer to UInt8.
                // This is safe since we'll copy out of this buffer as raw memory later.
                let capacity = buffer.pointee.capacity
