         // Copy as much as we can in one shot.
         let underestimatedCount = elements.underestimatedCount
         let originalCount = _representation.count
-        _representation._truncateOrZeroExtend(toCount: originalCount + underestimatedCount)
-        var (iter, copiedCount): (S.Iterator, Int) = _representation.withUnsafeMutableBytes { buffer in
+        _representation.count += underestimatedCount
+        var (iter, endIndex): (S.Iterator, Int) = _representation.withUnsafeMutableBytes { buffer in
             let start = buffer.baseAddress!.assumingMemoryBound(to: UInt8.self) + originalCount
             let b = UnsafeMutableBufferPointer(start: start, count: buffer.count - originalCount)
             return elements._copyContents(initializing: b)
         }
-        guard copiedCount == underestimatedCount else {
+        guard endIndex == underestimatedCount else {
             // We can't trap here. We have to allow an underfilled buffer
             // to emulate the previous implementation.
-            _representation._truncateOrZeroExtend(toCount: originalCount + copiedCount)
+            _representation.replaceSubrange(originalCount + endIndex ..< _representation.endIndex, with: nil, count: 0)
             return
         }
 

                }
            }
            set(newValue) {
                _truncateOrZeroExtend(toCount: newValue)
            }
        }


            }
        }

        @inlinable // This is @inlinable as reasonably small.
        var count: Int {
            get {
