 				}
 				let delta = oldOffset - header.pointee.offset
 				if info.start != 0 {
-					let destinationSplitIndices = Deque.indices(forRange: 0..<info.start, header: header)
+					let destinationSplitIndices = Deque.mapIndices(inRange: 0..<info.start, header: header)
 					let lowCount = destinationSplitIndices.low.count
 					Deque.moveInitialize(preMappedSourceRange: delta..<(delta + lowCount), postMappedDestinationRange: destinationSplitIndices.low, sourceHeader: header, sourceBody: body, destinationBody: body)
 					if lowCount != info.start {

	}
}

func roundUp(_ offset: UInt, toAlignment alignment: Int) -> UInt {
  let x = offset + UInt(bitPattern: alignment) &- 1
  return x & ~(UInt(bitPattern: alignment) &- 1)
}

struct HeapObject {
	let metadata: Int = 0
	let strongRefCount: UInt32 = 0
	let weakRefCount: UInt32 = 0
}

struct DequeHeader {
	var offset: Int
	var count: Int
	var capacity: Int
}

struct DequeMutationInfo {
	let start: Int
	let removed: Int
	let inserted: Int
	let newCount: Int
	
	init(subrange: Range<Int>, previousCount: Int, insertedCount: Int) {
		precondition(subrange.upperBound <= previousCount, "Subrange upperBound is out of range")

		self.start = subrange.lowerBound
		self.removed = subrange.count
		self.inserted = insertedCount
		self.newCount = previousCount - self.removed + self.inserted
	}
}

		return replaceSubrange(index..<index, with: CollectionOfOne(newElement))
	}
	
	/// Optimized implementation of RangeReplaceableCollection function
	public mutating func insert(_ newElement: T, at: Int) {
		if let b = buffer {
			let done = b.withUnsafeMutablePointers { header, body -> Bool in
