0001    //
0002    //  Deque.swift
0003    //  Deque
0004    //
0005    //  Created by Károly Lőrentey on 2016-01-20.
0006    //  Copyright © 2016 Károly Lőrentey.
0007    //
0008    
0009    import Foundation
0010    
0011    //MARK: Deque
0012    
0013    /// A double-ended queue type. `Deque` is an `Array`-like random-access collection of arbitrary elements
0014    /// that provides efficient insertion and deletion at both ends.
0015    ///
0016    /// Like arrays, deques are value types with copy-on-write semantics. `Deque` allocates a single buffer for
0017    /// element storage, using an exponential growth strategy.
0018    ///
0019    public struct DequeDeque.swift:46 extension Deque {
Deque.swift:84 extension Deque: MutableCollectionType {
Deque.swift:86     public typealias Generator = IndexingGenerator<Deque<Element>>
Deque.swift:87     public typealias SubSequence = MutableSlice<Deque<Element>>
Deque.swift:119 extension Deque: ArrayLiteralConvertible {
Deque.swift:128 extension Deque: CustomStringConvertible, CustomDebugStringConvertible {
Deque.swift:131         var result = debug ? "\(String(reflecting: Deque.self))([" : "Deque["
Deque.swift:160 extension Deque: RangeReplaceableCollectionType {
Deque.swift:282 extension Deque {
Deque.swift:328 func == <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:328 func == <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:343 func != <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:343 func != <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:826 extension Deque {<ElementDeque.swift:21     internal private(set) var buffer: DequeBuffer<Element>
Deque.swift:33     public init<S: SequenceType where S.Generator.Element == Element>(_ elements: S) {
Deque.swift:39     public init(count: Int, repeatedValue: Element) {> {
0020        /// The storage for this deque.
0021        internal private(set) var bufferDeque.swift:25         buffer = DequeBuffer()
Deque.swift:29         buffer = DequeBuffer(capacity: minimumCapacity)
Deque.swift:40         buffer = DequeBuffer(count: count, repeatedValue: repeatedValue)
Deque.swift:48     var capacity: Int { return buffer.capacity }
Deque.swift:57         guard buffer.capacity < minimumCapacity else { return }
Deque.swift:58         if isUniquelyReferenced(&buffer) {
Deque.swift:59             buffer = buffer.realloc(minimumCapacity)
Deque.swift:59             buffer = buffer.realloc(minimumCapacity)
Deque.swift:63             new.insertContentsOf(buffer, at: 0)
Deque.swift:64             buffer = new
Deque.swift:68     internal var isUnique: Bool { mutating get { return isUniquelyReferenced(&buffer) } }
Deque.swift:71         self.makeUniqueWithCapacity(buffer.capacity)
Deque.swift:75         guard !isUnique || buffer.capacity < capacity else { return }
Deque.swift:77         copy.insertContentsOf(buffer, at: 0)
Deque.swift:78         buffer = copy
Deque.swift:90     public var count: Int { return buffer.count }
Deque.swift:108             return buffer[index]
Deque.swift:112             buffer[index] = value
Deque.swift:121         self.buffer = DequeBuffer(capacity: elements.count)
Deque.swift:122         buffer.insertContentsOf(elements, at: 0)
Deque.swift:170             buffer.replaceRange(range, with: newElements)
Deque.swift:174             b.insertContentsOf(self.buffer, subRange: 0 ..< range.startIndex, at: 0)
Deque.swift:176             b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
Deque.swift:177             buffer = b
Deque.swift:186         buffer.append(newElement)
Deque.swift:192         var capacity = buffer.capacity
Deque.swift:193         var count = buffer.count
Deque.swift:199                 capacity = buffer.capacity
Deque.swift:201             var i = buffer.bufferIndexForDequeIndex(count)
Deque.swift:202             let p = buffer.elements
Deque.swift:210             buffer.count = count
Deque.swift:219         buffer.insert(newElement, at: i)
Deque.swift:227         buffer.insertContentsOf(newElements, at: i)
Deque.swift:236         let element = buffer[i]
Deque.swift:237         buffer.removeRange(i...i)
Deque.swift:247         return buffer.popFirst()!
Deque.swift:256         buffer.removeRange(0 ..< n)
Deque.swift:265         buffer.removeRange(range)
Deque.swift:273             buffer.removeRange(0..<count)
Deque.swift:276             buffer = DequeBuffer()
Deque.swift:289         return buffer.popLast()!
Deque.swift:299         buffer.removeRange(c - n ..< c)
Deque.swift:306         return buffer.popFirst()
Deque.swift:313         return buffer.popLast()
Deque.swift:321         buffer.prepend(element)
Deque.swift:331     if count == 0 || a.buffer === b.buffer { return true }
Deque.swift:331     if count == 0 || a.buffer === b.buffer { return true }
Deque.swift:828         try withExtendedLifetime(buffer) { buffer in: DequeBuffer<Element>
0022    
0023        /// Initializes an empty deque.
0024        public init() {
0025            buffer = DequeBuffer()
0026        }
0027        /// Initializes an empty deque that is able to store at least `minimumCapacity` items without reallocating its storage.
0028        public initDeque.swift:34         self.init(minimumCapacity: elements.underestimateCount())(minimumCapacity: Int) {
0029            buffer = DequeBuffer(capacity: minimumCapacity)
0030        }
0031    
0032        /// Initialize a new deque from the elements of any sequence.
0033        public init<S: SequenceType where S.Generator.Element == Element>(_ elements: S) {
0034            self.init(minimumCapacity: elements.underestimateCount())
0035            appendContentsOf(elements)
0036        }
0037    
0038        /// Initialize a deque of `count` elements, each initialized to `repeatedValue`.
0039        public init(count: Int, repeatedValue: Element) {
0040            buffer = DequeBuffer(count: count, repeatedValue: repeatedValue)
0041        }
0042    }
0043    
0044    //MARK: Uniqueness and Capacity
0045    
0046    extension Deque {
0047        /// The maximum number of items this deque can store without reallocating its storage.
0048        var capacityDeque.swift:51         guard capacity > self.capacity else { return self.capacity }
Deque.swift:51         guard capacity > self.capacity else { return self.capacity }
Deque.swift:52         return max(capacity, 2 * self.capacity)
Deque.swift:169         if isUnique && count + delta <= capacity {: Int { return buffer.capacity }
0049    
0050        private func growDeque.swift:173             let b = DequeBuffer<Element>(capacity: grow(count + delta))
Deque.swift:185         makeUniqueWithCapacity(grow(count + 1))
Deque.swift:198                 reserveCapacity(grow(count + 1))
Deque.swift:218         makeUniqueWithCapacity(grow(count + 1))
Deque.swift:226         makeUniqueWithCapacity(grow(count + numericCast(newElements.count)))
Deque.swift:320         makeUniqueWithCapacity(grow(count + 1))(capacity: Int) -> Int {
0051            guard capacity > self.capacity else { return self.capacity }
0052            return max(capacity, 2 * self.capacity)
0053        }
0054    
0055        /// Ensure that this deque is capable of storing at least `minimumCapacity` items without reallocating its storage.
0056        public mutating func reserveCapacityDeque.swift:198                 reserveCapacity(grow(count + 1))(minimumCapacity: Int) {
0057            guard buffer.capacity < minimumCapacity else { return }
0058            if isUniquelyReferenced(&buffer) {
0059                buffer = buffer.realloc(minimumCapacity)
0060            }
0061            else {
0062                let new = DequeBuffer<Element>(capacity: minimumCapacity)
0063                new.insertContentsOf(buffer, at: 0)
0064                buffer = new
0065            }
0066        }
0067    
0068        internal var isUniqueDeque.swift:75         guard !isUnique || buffer.capacity < capacity else { return }
Deque.swift:169         if isUnique && count + delta <= capacity {: Bool { mutating get { return isUniquelyReferenced(&buffer) } }
0069    
0070        private mutating func makeUniqueDeque.swift:235         makeUnique()() {
0071            self.makeUniqueWithCapacity(buffer.capacity)
0072        }
0073    
0074        private mutating func makeUniqueWithCapacityDeque.swift:71         self.makeUniqueWithCapacity(buffer.capacity)
Deque.swift:185         makeUniqueWithCapacity(grow(count + 1))
Deque.swift:191         makeUniqueWithCapacity(self.count + newElements.underestimateCount())
Deque.swift:218         makeUniqueWithCapacity(grow(count + 1))
Deque.swift:226         makeUniqueWithCapacity(grow(count + numericCast(newElements.count)))
Deque.swift:320         makeUniqueWithCapacity(grow(count + 1))(capacity: Int) {
0075            guard !isUnique || buffer.capacity < capacity else { return }
0076            let copy = DequeBuffer<Element>(capacity: capacity)
0077            copy.insertContentsOf(buffer, at: 0)
0078            buffer = copy
0079        }
0080    }
0081    
0082    //MARK: MutableCollectionType
0083    
0084    extension Deque: MutableCollectionType {
0085        public typealias Index = Int
0086        public typealias Generator = IndexingGenerator<Deque<Element>>
0087        public typealias SubSequence = MutableSlice<Deque<Element>>
0088    
0089        /// The number of elements currently stored in this deque.
0090        public var countDeque.swift:94     public var endIndex: Int { return count }
Deque.swift:97     public var isEmpty: Bool { return count == 0 }
Deque.swift:101         precondition(index >= 0 && index < count)
Deque.swift:166         precondition(range.startIndex >= 0 && range.endIndex <= count)
Deque.swift:169         if isUnique && count + delta <= capacity {
Deque.swift:173             let b = DequeBuffer<Element>(capacity: grow(count + delta))
Deque.swift:176             b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
Deque.swift:185         makeUniqueWithCapacity(grow(count + 1))
Deque.swift:191         makeUniqueWithCapacity(self.count + newElements.underestimateCount())
Deque.swift:218         makeUniqueWithCapacity(grow(count + 1))
Deque.swift:226         makeUniqueWithCapacity(grow(count + numericCast(newElements.count)))
Deque.swift:246         precondition(count > 0)
Deque.swift:255         precondition(count >= n)
Deque.swift:264         precondition(range.startIndex >= 0 && range.endIndex <= count)
Deque.swift:273             buffer.removeRange(0..<count)
Deque.swift:288         precondition(count > 0)
Deque.swift:297         let c = count
Deque.swift:320         makeUniqueWithCapacity(grow(count + 1))
Deque.swift:329     let count = a.count
Deque.swift:330     if count != b.count { return false }
Deque.swift:835         result.reserveCapacity(self.count): Int { return buffer.count }
0091        /// The position of the first element in a non-empty deque (this is always zero).
0092        public var startIndex: Int { return 0 }
0093        /// The index after the last element in a non-empty deque (this is always the element count).
0094        public var endIndex: Int { return count }
0095    
0096        /// `true` iff this deque is empty.
0097        public var isEmpty: Bool { return count == 0 }
0098    
0099        @inline(__always)
0100        private func checkSubscriptDeque.swift:107             checkSubscript(index)
Deque.swift:111             checkSubscript(index)
Deque.swift:234         checkSubscript(i)(index: Int) {
0101            precondition(index >= 0 && index < count)
0102        }
0103    
0104        // Returns or changes the element at `index`.
0105        public subscript(index: Int) -> Element {
0106            get {
0107                checkSubscript(index)
0108                return buffer[index]
0109            }
0110            set(value) {
0111                checkSubscript(index)
0112                buffer[index] = value
0113            }
0114        }
0115    }
0116    
0117    //MARK: ArrayLiteralConvertible
0118    
0119    extension Deque: ArrayLiteralConvertible {
0120        public init(arrayLiteral elements: Element...) {
0121            self.buffer = DequeBuffer(capacity: elements.count)
0122            buffer.insertContentsOf(elements, at: 0)
0123        }
0124    }
0125    
0126    //MARK: CustomStringConvertible
0127    
0128    extension Deque: CustomStringConvertible, CustomDebugStringConvertible {
0129        @warn_unused_result
0130        private func makeDescriptionDeque.swift:151         return makeDescription(debug: false)
Deque.swift:154         return makeDescription(debug: true)(debug debug: Bool) -> String {
0131            var result = debug ? "\(String(reflecting: Deque.self))([" : "Deque["
0132            var first = true
0133            for item in self {
0134                if first {
0135                    first = false
0136                } else {
0137                    result += ", "
0138                }
0139                if debug {
0140                    debugPrint(item, terminator: "", toStream: &result)
0141                }
0142                else {
0143                    print(item, terminator: "", toStream: &result)
0144                }
0145            }
0146            result += debug ? "])" : "]"
0147            return result
0148        }
0149    
0150        public var description: String {
0151            return makeDescription(debug: false)
0152        }
0153        public var debugDescription: String {
0154            return makeDescription(debug: true)
0155        }
0156    }
0157    
0158    //MARK: RangeReplaceableCollectionType
0159    
0160    extension Deque: RangeReplaceableCollectionType {
0161        /// Replace the given `range` of elements with `newElements`.
0162        ///
0163        /// - Complexity: O(`range.count`) if storage isn't shared with another live deque, 
0164        ///   and `range` is a constant distance from the start or the end of the deque; otherwise O(`count + range.count`).
0165        public mutating func replaceRange<C: CollectionType where C.Generator.Element == Element>(range: Range<Int>, with newElements: C) {
0166            precondition(range.startIndex >= 0 && range.endIndex <= count)
0167            let newCount: Int = numericCast(newElements.count)
0168            let delta = newCount - range.count
0169            if isUnique && count + delta <= capacity {
0170                buffer.replaceRange(range, with: newElements)
0171            }
0172            else {
0173                let b = DequeBuffer<Element>(capacity: grow(count + delta))
0174                b.insertContentsOf(self.buffer, subRange: 0 ..< range.startIndex, at: 0)
0175                b.insertContentsOf(newElements, at: b.count)
0176                b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
0177                buffer = b
0178            }
0179        }
0180    
0181        /// Append `newElement` to the end of this deque.
0182        ///
0183        /// - Complexity: Amortized O(1) if storage isn't shared with another live deque; otherwise O(`count`).
0184        public mutating func append(newElement: Element) {
0185            makeUniqueWithCapacity(grow(count + 1))
0186            buffer.append(newElement)
0187        }
0188    
0189        /// Append `newElements` to the end of this queue.
0190        public mutating func appendContentsOfDeque.swift:35         appendContentsOf(elements)<S: SequenceType where S.Generator.Element == Element>(newElements: S) {
0191            makeUniqueWithCapacity(self.count + newElements.underestimateCount())
0192            var capacity = buffer.capacity
0193            var count = buffer.count
0194            var generator = newElements.generate()
0195            var next = generator.next()
0196            while next != nil {
0197                if capacity == count {
0198                    reserveCapacity(grow(count + 1))
0199                    capacity = buffer.capacity
0200                }
0201                var i = buffer.bufferIndexForDequeIndex(count)
0202                let p = buffer.elements
0203                while let element = next where count < capacity {
0204                    p.advancedBy(i).initialize(element)
0205                    i += 1
0206                    if i == capacity { i = 0 }
0207                    count += 1
0208                    next = generator.next()
0209                }
0210                buffer.count = count
0211            }
0212        }
0213    
0214        /// Insert `newElement` at index `i` into this deque.
0215        ///
0216        /// - Complexity: O(`count`). Note though that complexity is O(1) if `i` is of a constant distance from the front or end of the deque.
0217        public mutating func insert(newElement: Element, atIndex i: Int) {
0218            makeUniqueWithCapacity(grow(count + 1))
0219            buffer.insert(newElement, at: i)
0220        }
0221    
0222        /// Insert the contents of `newElements` into this deque, starting at index `i`.
0223        ///
0224        /// - Complexity: O(`count`). Note though that complexity is O(1) if `i` is of a constant distance from the front or end of the deque.
0225        public mutating func insertContentsOf<C: CollectionType where C.Generator.Element == Element>(newElements: C, at i: Int) {
0226            makeUniqueWithCapacity(grow(count + numericCast(newElements.count)))
0227            buffer.insertContentsOf(newElements, at: i)
0228        }
0229    
0230        /// Remove the element at index `i` from this deque.
0231        ///
0232        /// - Complexity: O(`count`). Note though that complexity is O(1) if `i` is of a constant distance from the front or end of the deque.
0233        public mutating func removeAtIndex(i: Int) -> Element {
0234            checkSubscript(i)
0235            makeUnique()
0236            let element = buffer[i]
0237            buffer.removeRange(i...i)
0238            return element
0239        }
0240    
0241        /// Remove and return the first element from this deque.
0242        ///
0243        /// - Requires: `count > 0`
0244        /// - Complexity: O(1) if storage isn't shared with another live deque; otherwise O(`count`).
0245        public mutating func removeFirst() -> Element {
0246            precondition(count > 0)
0247            return buffer.popFirst()!
0248        }
0249    
0250        /// Remove the first `n` elements from this deque.
0251        ///
0252        /// - Requires: `count >= n`
0253        /// - Complexity: O(`n`) if storage isn't shared with another live deque; otherwise O(`count`).
0254        public mutating func removeFirst(n: Int) {
0255            precondition(count >= n)
0256            buffer.removeRange(0 ..< n)
0257        }
0258    
0259        /// Remove the first `n` elements from this deque.
0260        ///
0261        /// - Requires: `count >= n`
0262        /// - Complexity: O(`n`) if storage isn't shared with another live deque; otherwise O(`count`).
0263        public mutating func removeRange(range: Range<Int>) {
0264            precondition(range.startIndex >= 0 && range.endIndex <= count)
0265            buffer.removeRange(range)
0266        }
0267    
0268        /// Remove all elements from this deque.
0269        ///
0270        /// - Complexity: O(`count`).
0271        public mutating func removeAll(keepCapacity keepCapacity: Bool = false) {
0272            if keepCapacity {
0273                buffer.removeRange(0..<count)
0274            }
0275            else {
0276                buffer = DequeBuffer()
0277            }
0278        }
0279    }
0280    
0281    //MARK: Miscellaneous mutators
0282    extension Deque {
0283        /// Remove and return the last element from this deque.
0284        ///
0285        /// - Requires: `count > 0`
0286        /// - Complexity: O(1) if storage isn't shared with another live deque; otherwise O(`count`).
0287        public mutating func removeLast() -> Element {
0288            precondition(count > 0)
0289            return buffer.popLast()!
0290        }
0291    
0292        /// Remove and return the last `n` elements from this deque.
0293        ///
0294        /// - Requires: `count >= n`
0295        /// - Complexity: O(`n`) if storage isn't shared with another live deque; otherwise O(`count`).
0296        public mutating func removeLast(n: Int) {
0297            let c = count
0298            precondition(c >= n)
0299            buffer.removeRange(c - n ..< c)
0300        }
0301    
0302        /// Remove and return the first element if the deque isn't empty; otherwise return nil.
0303        ///
0304        /// - Complexity: O(1) if storage isn't shared with another live deque; otherwise O(`count`).
0305        public mutating func popFirst() -> Element? {
0306            return buffer.popFirst()
0307        }
0308    
0309        /// Remove and return the last element if the deque isn't empty; otherwise return nil.
0310        ///
0311        /// - Complexity: O(1) if storage isn't shared with another live deque; otherwise O(`count`).
0312        public mutating func popLast() -> Element? {
0313            return buffer.popLast()
0314        }
0315    
0316        /// Prepend `newElement` to the front of this deque.
0317        ///
0318        /// - Complexity: Amortized O(1) if storage isn't shared with another live deque; otherwise O(count).
0319        public mutating func prepend(element: Element) {
0320            makeUniqueWithCapacity(grow(count + 1))
0321            buffer.prepend(element)
0322        }
0323    }
0324    
0325    //MARK: Equality operators
0326    
0327    @warn_unused_result
0328    func == <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
0329        let count = a.count
0330        if count != b.count { return false }
0331        if count == 0 || a.buffer === b.buffer { return true }
0332    
0333        var agen = a.generate()
0334        var bgen = b.generate()
0335        while let anext = agen.next() {
0336            let bnext = bgen.next()
0337            if anext != bnext { return false }
0338        }
0339        return true
0340    }
0341    
0342    @warn_unused_result
0343    func != <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
0344        return !(a == b)
0345    }
0346    
0347    //MARK: DequeBuffer
0348    
0349    /// Storage buffer for a deque.
0350    final class DequeBufferDeque.swift:21     internal private(set) var buffer: DequeBuffer<Element>
Deque.swift:25         buffer = DequeBuffer()
Deque.swift:29         buffer = DequeBuffer(capacity: minimumCapacity)
Deque.swift:40         buffer = DequeBuffer(count: count, repeatedValue: repeatedValue)
Deque.swift:62             let new = DequeBuffer<Element>(capacity: minimumCapacity)
Deque.swift:76         let copy = DequeBuffer<Element>(capacity: capacity)
Deque.swift:121         self.buffer = DequeBuffer(capacity: elements.count)
Deque.swift:173             let b = DequeBuffer<Element>(capacity: grow(count + delta))
Deque.swift:276             buffer = DequeBuffer()
Deque.swift:395     internal func realloc(capacity: Int) -> DequeBuffer {
Deque.swift:397         let buffer = DequeBuffer(capacity: capacity)
Deque.swift:577     internal func insertContentsOf(buffer: DequeBuffer, at index: Int) {
Deque.swift:581     internal func insertContentsOf(buffer: DequeBuffer, subRange: Range<Int>, at index: Int) {
Deque.swift:802 extension DequeBuffer {<ElementDeque.swift:352     internal private(set) var elements: UnsafeMutablePointer<Element>
Deque.swift:369     internal convenience init(count: Int, repeatedValue: Element) {
Deque.swift:444     internal func prepend(element: Element) {
Deque.swift:452     internal func popFirst() -> Element? {
Deque.swift:460     internal func append(element: Element) {
Deque.swift:467     internal func popLast() -> Element? {
Deque.swift:570     internal func insert(element: Element, at index: Int) {
Deque.swift:634     internal func insertContentsOf<C: CollectionType where C.Generator.Element == Element>(collection: C, at index: Int) {
Deque.swift:763     internal func replaceRange<C: CollectionType where C.Generator.Element == Element>(range: Range<Int>, with newElements: C) {>: NonObjectiveCBase {
0351        /// Pointer to allocated storage.
0352        internal private(set) var elementsDeque.swift:202             let p = buffer.elements
Deque.swift:363         self.elements = UnsafeMutablePointer.alloc(capacity)
Deque.swift:371         let p = elements
Deque.swift:382         let p = self.elements
Deque.swift:399         let dst = buffer.elements
Deque.swift:400         let src = self.elements
Deque.swift:435             return elements.advancedBy(i).memory
Deque.swift:440             elements.advancedBy(i).memory = newValue
Deque.swift:447         elements.advancedBy(i).initialize(element)
Deque.swift:454         let first = elements.advancedBy(start).move()
Deque.swift:463         elements.advancedBy(endIndex).initialize(element)
Deque.swift:470         let last = elements.advancedBy(lastIndex).move()
Deque.swift:490                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: end - i)
Deque.swift:490                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: end - i)
Deque.swift:495                     elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:495                     elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:497                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:497                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:502                     elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: end - i)
Deque.swift:502                     elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: end - i)
Deque.swift:509                     elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:509                     elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:511                     elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: length)
Deque.swift:511                     elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: length)
Deque.swift:513                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:513                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:518                     elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:518                     elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:520                     elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:520                     elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:531                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:531                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:536                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:536                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:538                     elements.moveInitializeFrom(elements.advancedBy(length), count: i - length)
Deque.swift:538                     elements.moveInitializeFrom(elements.advancedBy(length), count: i - length)
Deque.swift:543                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:543                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:550                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:550                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:552                     elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: length)
Deque.swift:552                     elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: length)
Deque.swift:554                     elements.moveInitializeFrom(elements.advancedBy(i - length), count: i - length)
Deque.swift:554                     elements.moveInitializeFrom(elements.advancedBy(i - length), count: i - length)
Deque.swift:559                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:561                     elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: i)
Deque.swift:561                     elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: i)
Deque.swift:574         elements.advancedBy(i).initialize(element)
Deque.swift:589         let dp = self.elements
Deque.swift:590         let sp = buffer.elements
Deque.swift:640         var q = elements.advancedBy(bufferIndexForDequeIndex(index))
Deque.swift:641         let limit = elements.advancedBy(capacity)
Deque.swift:646                 q = elements
Deque.swift:658         let p = elements
Deque.swift:769             let p = elements
Deque.swift:786             let p = elements
Deque.swift:805             var p = elements + start
Deque.swift:812             var p = elements + start
Deque.swift:817             p = elements: UnsafeMutablePointer<Element>
0353        /// The capacity of this storage buffer.
0354        internal let capacityDeque.swift:48     var capacity: Int { return buffer.capacity }
Deque.swift:57         guard buffer.capacity < minimumCapacity else { return }
Deque.swift:71         self.makeUniqueWithCapacity(buffer.capacity)
Deque.swift:75         guard !isUnique || buffer.capacity < capacity else { return }
Deque.swift:192         var capacity = buffer.capacity
Deque.swift:199                 capacity = buffer.capacity
Deque.swift:364         self.capacity = capacity
Deque.swift:383         if start + count <= capacity {
Deque.swift:387             let c = capacity - start
Deque.swift:391         p.dealloc(capacity)
Deque.swift:396         if capacity <= self.capacity { return self }
Deque.swift:401         if self.start + self.count <= self.capacity {
Deque.swift:405             let c = self.capacity - self.start
Deque.swift:417         if i >= capacity { return i - capacity }
Deque.swift:417         if i >= capacity { return i - capacity }
Deque.swift:426         return capacity - start + i
Deque.swift:429     internal var isFull: Bool { return count == capacity }
Deque.swift:445         precondition(count < capacity)
Deque.swift:446         let i = start == 0 ? capacity - 1 : start - 1
Deque.swift:461         precondition(count < capacity)
Deque.swift:481         assert(count + length <= capacity)
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:488                 if end + length <= capacity { // Neither gap nor elements after it will be wrapped
Deque.swift:493                 else if i + length <= capacity { // Elements after gap will be wrapped
Deque.swift:495                     elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:495                     elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:497                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:502                     elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: end - i)
Deque.swift:507                 if i + length <= capacity { // Gap will not be wrapped
Deque.swift:511                     elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: length)
Deque.swift:513                     elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:520                     elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:520                     elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:536                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:543                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:550                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:552                     elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: length)
Deque.swift:559                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:561                     elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: i)
Deque.swift:565             start = start < length ? capacity + start - length : start - length
Deque.swift:584         assert(count + subRange.count <= capacity)
Deque.swift:604             let t = buffer.capacity - srcStart
Deque.swift:609             let t = self.capacity - dstStart
Deque.swift:614             let st = buffer.capacity - srcStart
Deque.swift:615             let dt = self.capacity - dstStart
Deque.swift:637         assert(count + c <= capacity)
Deque.swift:641         let limit = elements.advancedBy(capacity)
Deque.swift:660         let j = i + rc <= capacity ? i + rc : i + rc - capacity
Deque.swift:660         let j = i + rc <= capacity ? i + rc : i + rc - capacity
Deque.swift:670             p.advancedBy(i).destroy(capacity - i)
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:685             else if i + rc > capacity { // Collapsed range is wrapped
Deque.swift:688                     p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity + end - i - rc)
Deque.swift:688                     p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity + end - i - rc)
Deque.swift:693                     p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity - i)
Deque.swift:693                     p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity - i)
Deque.swift:702                     p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc), count: capacity - i - rc)
Deque.swift:704                     p.advancedBy(capacity - rc).moveInitializeFrom(p, count: end)
Deque.swift:709                     p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc), count: capacity - i - rc)
Deque.swift:711                     p.advancedBy(capacity - rc).moveInitializeFrom(p, count: rc)
Deque.swift:727                 if  start + rc >= capacity  { // Result will not be wrapped
Deque.swift:729                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:729                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:734                     p.moveInitializeFrom(p.advancedBy(capacity - rc), count: j)
Deque.swift:736                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:741                 if capacity - start <= rc { // Result will not be wrapped
Deque.swift:745                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:745                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:752                     p.moveInitializeFrom(p.advancedBy(capacity) - rc, count: rc)
Deque.swift:754                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:758             start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758             start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:766         assert(count + delta < capacity)
Deque.swift:771             let limit = p.advancedBy(capacity)
Deque.swift:788             let limit = p.advancedBy(capacity)
Deque.swift:804         if start + count <= capacity {
Deque.swift:813             for _ in start ..< capacity {
Deque.swift:818             for _ in 0 ..< start + count - capacity {: Int
0355        /// The number of items currently in this deque.
0356        internal private(set) var countDeque.swift:90     public var count: Int { return buffer.count }
Deque.swift:175             b.insertContentsOf(newElements, at: b.count)
Deque.swift:176             b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
Deque.swift:193         var count = buffer.count
Deque.swift:210             buffer.count = count
Deque.swift:365         self.count = 0
Deque.swift:372         self.count = count
Deque.swift:383         if start + count <= capacity {
Deque.swift:384             p.advancedBy(start).destroy(count)
Deque.swift:389             p.destroy(count - c)
Deque.swift:398         buffer.count = self.count
Deque.swift:398         buffer.count = self.count
Deque.swift:401         if self.start + self.count <= self.capacity {
Deque.swift:402             dst.moveInitializeFrom(src.advancedBy(start), count: count)
Deque.swift:407             dst.advancedBy(c).moveInitializeFrom(src, count: self.count - c)
Deque.swift:409         self.count = 0
Deque.swift:429     internal var isFull: Bool { return count == capacity }
Deque.swift:433             assert(index >= 0 && index < count)
Deque.swift:438             assert(index >= 0 && index < count)
Deque.swift:445         precondition(count < capacity)
Deque.swift:449         self.count += 1
Deque.swift:453         guard count > 0 else { return nil }
Deque.swift:456         self.count -= 1
Deque.swift:461         precondition(count < capacity)
Deque.swift:462         let endIndex = bufferIndexForDequeIndex(count)
Deque.swift:464         self.count += 1
Deque.swift:468         guard count > 0 else { return nil }
Deque.swift:469         let lastIndex = bufferIndexForDequeIndex(count - 1)
Deque.swift:471         self.count -= 1
Deque.swift:480         assert(index >= 0 && index <= self.count)
Deque.swift:481         assert(count + length <= capacity)
Deque.swift:484         if index >= (count + 1) / 2 {
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:524             count += length
Deque.swift:566             count += length
Deque.swift:571         precondition(index >= 0 && index <= count && !isFull)
Deque.swift:578         self.insertContentsOf(buffer, subRange: 0 ..< buffer.count, at: index)
Deque.swift:583         assert(index >= 0 && index <= count)
Deque.swift:584         assert(count + subRange.count <= capacity)
Deque.swift:585         assert(subRange.startIndex >= 0 && subRange.endIndex <= buffer.count)
Deque.swift:635         assert(index >= 0 && index <= count)
Deque.swift:637         assert(count + c <= capacity)
Deque.swift:655         assert(range.endIndex <= self.count)
Deque.swift:676         if count - range.startIndex - rc < range.startIndex {
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:717             count -= rc
Deque.swift:759             count -= rc
Deque.swift:766         assert(count + delta < capacity)
Deque.swift:804         if start + count <= capacity {
Deque.swift:806             for _ in 0 ..< count {
Deque.swift:818             for _ in 0 ..< start + count - capacity {: Int
0357        /// The index of the first item.
0358        internal private(set) var startDeque.swift:366         self.start = 0
Deque.swift:383         if start + count <= capacity {
Deque.swift:384             p.advancedBy(start).destroy(count)
Deque.swift:387             let c = capacity - start
Deque.swift:388             p.advancedBy(start).destroy(c)
Deque.swift:401         if self.start + self.count <= self.capacity {
Deque.swift:402             dst.moveInitializeFrom(src.advancedBy(start), count: count)
Deque.swift:405             let c = self.capacity - self.start
Deque.swift:406             dst.moveInitializeFrom(src.advancedBy(self.start), count: c)
Deque.swift:416         let i = start + index
Deque.swift:423         if i >= start {
Deque.swift:424             return i - start
Deque.swift:426         return capacity - start + i
Deque.swift:446         let i = start == 0 ? capacity - 1 : start - 1
Deque.swift:446         let i = start == 0 ? capacity - 1 : start - 1
Deque.swift:448         self.start = i
Deque.swift:454         let first = elements.advancedBy(start).move()
Deque.swift:455         self.start = bufferIndexForDequeIndex(1)
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486             let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:528             if i >= start { // Elements before index are not yet wrapped.
Deque.swift:529                 if start >= length { // Neither gap nor elements before it will be wrapped.
Deque.swift:531                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:531                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:531                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:536                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:536                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:536                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:543                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:543                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:543                     elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:550                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:550                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:550                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559                     elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:565             start = start < length ? capacity + start - length : start - length
Deque.swift:565             start = start < length ? capacity + start - length : start - length
Deque.swift:565             start = start < length ? capacity + start - length : start - length
Deque.swift:565             start = start < length ? capacity + start - length : start - length
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677             let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:721             if j >= start { // No wrap anywhere before end of collapsed range
Deque.swift:723                 p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: j - start - rc)
Deque.swift:723                 p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: j - start - rc)
Deque.swift:723                 p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: j - start - rc)
Deque.swift:727                 if  start + rc >= capacity  { // Result will not be wrapped
Deque.swift:729                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:729                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:729                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:736                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:736                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:736                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:741                 if capacity - start <= rc { // Result will not be wrapped
Deque.swift:745                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:745                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:745                     p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:754                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:754                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:754                     p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:758             start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758             start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758             start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758             start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:804         if start + count <= capacity {
Deque.swift:805             var p = elements + start
Deque.swift:812             var p = elements + start
Deque.swift:813             for _ in start ..< capacity {
Deque.swift:818             for _ in 0 ..< start + count - capacity {: Int
0359    
0360        internal initDeque.swift:25         buffer = DequeBuffer()
Deque.swift:29         buffer = DequeBuffer(capacity: minimumCapacity)
Deque.swift:121         self.buffer = DequeBuffer(capacity: elements.count)
Deque.swift:276             buffer = DequeBuffer()
Deque.swift:370         self.init(capacity: count)
Deque.swift:397         let buffer = DequeBuffer(capacity: capacity)(capacity: Int = 16) {
0361            // TODO: It would be nicer if element storage was tail-allocated after this instance.
0362            // ManagedBuffer is supposed to do that, but ManagedBuffer is surprisingly slow. :-/
0363            self.elements = UnsafeMutablePointer.alloc(capacity)
0364            self.capacity = capacity
0365            self.count = 0
0366            self.start = 0
0367        }
0368    
0369        internal convenience initDeque.swift:40         buffer = DequeBuffer(count: count, repeatedValue: repeatedValue)(count: Int, repeatedValue: Element) {
0370            self.init(capacity: count)
0371            let p = elements
0372            self.count = count
0373            var q = p
0374            let limit = p + count
0375            while q != limit {
0376                q.initialize(repeatedValue)
0377                q += 1
0378            }
0379        }
0380    
0381        deinit {
0382            let p = self.elements
0383            if start + count <= capacity {
0384                p.advancedBy(start).destroy(count)
0385            }
0386            else {
0387                let c = capacity - start
0388                p.advancedBy(start).destroy(c)
0389                p.destroy(count - c)
0390            }
0391            p.dealloc(capacity)
0392        }
0393    
0394        @warn_unused_result
0395        internal func reallocDeque.swift:59             buffer = buffer.realloc(minimumCapacity)(capacity: Int) -> DequeBuffer {
0396            if capacity <= self.capacity { return self }
0397            let buffer = DequeBuffer(capacity: capacity)
0398            buffer.count = self.count
0399            let dst = buffer.elements
0400            let src = self.elements
0401            if self.start + self.count <= self.capacity {
0402                dst.moveInitializeFrom(src.advancedBy(start), count: count)
0403            }
0404            else {
0405                let c = self.capacity - self.start
0406                dst.moveInitializeFrom(src.advancedBy(self.start), count: c)
0407                dst.advancedBy(c).moveInitializeFrom(src, count: self.count - c)
0408            }
0409            self.count = 0
0410            return buffer
0411        }
0412    
0413    
0414        /// Returns the storage buffer index for a deque index.
0415        internal func bufferIndexForDequeIndexDeque.swift:201             var i = buffer.bufferIndexForDequeIndex(count)
Deque.swift:434             let i = bufferIndexForDequeIndex(index)
Deque.swift:439             let i = bufferIndexForDequeIndex(index)
Deque.swift:455         self.start = bufferIndexForDequeIndex(1)
Deque.swift:462         let endIndex = bufferIndexForDequeIndex(count)
Deque.swift:469         let lastIndex = bufferIndexForDequeIndex(count - 1)
Deque.swift:483         let i = bufferIndexForDequeIndex(index)
Deque.swift:573         let i = bufferIndexForDequeIndex(index)
Deque.swift:592         let dstStart = self.bufferIndexForDequeIndex(index)
Deque.swift:593         let srcStart = buffer.bufferIndexForDequeIndex(subRange.startIndex)
Deque.swift:597         let dstEnd = self.bufferIndexForDequeIndex(index + srcCount)
Deque.swift:598         let srcEnd = buffer.bufferIndexForDequeIndex(subRange.endIndex)
Deque.swift:640         var q = elements.advancedBy(bufferIndexForDequeIndex(index))
Deque.swift:659         let i = bufferIndexForDequeIndex(range.startIndex)
Deque.swift:770             var q = p.advancedBy(bufferIndexForDequeIndex(range.startIndex))
Deque.swift:787             var q = p.advancedBy(bufferIndexForDequeIndex(range.startIndex + common))(index: Int) -> Int {
0416            let i = start + index
0417            if i >= capacity { return i - capacity }
0418            return i
0419        }
0420    
0421        /// Returns the deque index for a storage buffer index.
0422        internal func dequeIndexForBufferIndex(i: Int) -> Int {
0423            if i >= start {
0424                return i - start
0425            }
0426            return capacity - start + i
0427        }
0428    
0429        internal var isFullDeque.swift:571         precondition(index >= 0 && index <= count && !isFull): Bool { return count == capacity }
0430    
0431        internal subscriptDeque.swift:108             return buffer[index]
Deque.swift:112             buffer[index] = value
Deque.swift:236         let element = buffer[i](index: Int) -> Element {
0432            get {
0433                assert(index >= 0 && index < count)
0434                let i = bufferIndexForDequeIndex(index)
0435                return elements.advancedBy(i).memory
0436            }
0437            set {
0438                assert(index >= 0 && index < count)
0439                let i = bufferIndexForDequeIndex(index)
0440                elements.advancedBy(i).memory = newValue
0441            }
0442        }
0443    
0444        internal func prependDeque.swift:321         buffer.prepend(element)(element: Element) {
0445            precondition(count < capacity)
0446            let i = start == 0 ? capacity - 1 : start - 1
0447            elements.advancedBy(i).initialize(element)
0448            self.start = i
0449            self.count += 1
0450        }
0451    
0452        internal func popFirstDeque.swift:247         return buffer.popFirst()!
Deque.swift:306         return buffer.popFirst()() -> Element? {
0453            guard count > 0 else { return nil }
0454            let first = elements.advancedBy(start).move()
0455            self.start = bufferIndexForDequeIndex(1)
0456            self.count -= 1
0457            return first
0458        }
0459    
0460        internal func appendDeque.swift:186         buffer.append(newElement)(element: Element) {
0461            precondition(count < capacity)
0462            let endIndex = bufferIndexForDequeIndex(count)
0463            elements.advancedBy(endIndex).initialize(element)
0464            self.count += 1
0465        }
0466    
0467        internal func popLastDeque.swift:289         return buffer.popLast()!
Deque.swift:313         return buffer.popLast()() -> Element? {
0468            guard count > 0 else { return nil }
0469            let lastIndex = bufferIndexForDequeIndex(count - 1)
0470            let last = elements.advancedBy(lastIndex).move()
0471            self.count -= 1
0472            return last
0473        }
0474    
0475        /// Create a gap of `length` uninitialized slots starting at `index`.
0476        /// Existing elements are moved out of the way.
0477        /// You are expected to fill the gap by initializing all slots in it after calling this method.
0478        /// Note that all previously calculated buffer indexes are invalidated by this method.
0479        private func openGapAtDeque.swift:572         openGapAt(index, length: 1)
Deque.swift:587         openGapAt(index, length: subRange.count)
Deque.swift:639         openGapAt(index, length: c)
Deque.swift:785             openGapAt(range.startIndex + common, length: newCount - common)(index: Int, length: Int) {
0480            assert(index >= 0 && index <= self.count)
0481            assert(count + length <= capacity)
0482            guard length > 0 else { return }
0483            let i = bufferIndexForDequeIndex(index)
0484            if index >= (count + 1) / 2 {
0485                // Make room by sliding elements at/after index to the right
0486                let end = start + count <= capacity ? start + count : start + count - capacity
0487                if i <= end { // Elements after index are not yet wrapped
0488                    if end + length <= capacity { // Neither gap nor elements after it will be wrapped
0489                        // ....ABCD̲EF......
0490                        elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: end - i)
0491                        // ....ABC.̲..DEF...
0492                    }
0493                    else if i + length <= capacity { // Elements after gap will be wrapped
0494                        // .........ABCD̲EF. (count = 3)
0495                        elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
0496                        // EF.......ABCD̲...
0497                        elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
0498                        // EF.......ABC.̲..D
0499                    }
0500                    else { // Gap will be wrapped
0501                        // .........ABCD̲EF. (count = 5)
0502                        elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: end - i)
0503                        // .DEF.....ABC.̲...
0504                    }
0505                }
0506                else { // Elements after index are already wrapped
0507                    if i + length <= capacity { // Gap will not be wrapped
0508                        // F.......ABCD̲E (count = 1)
0509                        elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
0510                        // .F......ABCD̲E
0511                        elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: length)
0512                        // EF......ABCD̲.
0513                        elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
0514                        // EF......ABC.̲D
0515                    }
0516                    else { // Gap will be wrapped
0517                        // F.......ABCD̲E (count = 3)
0518                        elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
0519                        // ...F....ABCD̲E
0520                        elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
0521                        // .DEF....ABC.̲.
0522                    }
0523                }
0524                count += length
0525            }
0526            else {
0527                // Make room by sliding elements before index to the left, updating `start`.
0528                if i >= start { // Elements before index are not yet wrapped.
0529                    if start >= length { // Neither gap nor elements before it will be wrapped.
0530                        // ....ABCD̲EF...
0531                        elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
0532                        // .ABC...D̲EF...
0533                    }
0534                    else if i >= length { // Elements before the gap will be wrapped.
0535                        // ..ABCD̲EF....
0536                        elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
0537                        // ...BCD̲EF...A
0538                        elements.moveInitializeFrom(elements.advancedBy(length), count: i - length)
0539                        // BC...D̲EF...A
0540                    }
0541                    else { // Gap will be wrapped
0542                        // .ABCD̲EF....... (count = 5)
0543                        elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
0544                        // ....D̲EF...ABC.
0545                    }
0546                }
0547                else { // Elements before index are already wrapped.
0548                    if i >= length { // Gap will not be wrapped.
0549                        // BCD̲EF......A (count = 1)
0550                        elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
0551                        // BCD̲EF.....A.
0552                        elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: length)
0553                        // .CD̲EF.....AB
0554                        elements.moveInitializeFrom(elements.advancedBy(i - length), count: i - length)
0555                        // C.D̲EF.....AB
0556                    }
0557                    else { // Gap will be wrapped.
0558                        // CD̲EF......AB
0559                        elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
0560                        // CD̲EF...AB...
0561                        elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: i)
0562                        // .D̲EF...ABC..
0563                    }
0564                }
0565                start = start < length ? capacity + start - length : start - length
0566                count += length
0567            }
0568        }
0569    
0570        internal func insertDeque.swift:219         buffer.insert(newElement, at: i)(element: Element, at index: Int) {
0571            precondition(index >= 0 && index <= count && !isFull)
0572            openGapAt(index, length: 1)
0573            let i = bufferIndexForDequeIndex(index)
0574            elements.advancedBy(i).initialize(element)
0575        }
0576    
0577        internal func insertContentsOfDeque.swift:63             new.insertContentsOf(buffer, at: 0)
Deque.swift:77         copy.insertContentsOf(buffer, at: 0)(buffer: DequeBuffer, at index: Int) {
0578            self.insertContentsOf(buffer, subRange: 0 ..< buffer.count, at: index)
0579        }
0580    
0581        internal func insertContentsOfDeque.swift:174             b.insertContentsOf(self.buffer, subRange: 0 ..< range.startIndex, at: 0)
Deque.swift:176             b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
Deque.swift:578         self.insertContentsOf(buffer, subRange: 0 ..< buffer.count, at: index)(buffer: DequeBuffer, subRange: Range<Int>, at index: Int) {
0582            assert(buffer !== self)
0583            assert(index >= 0 && index <= count)
0584            assert(count + subRange.count <= capacity)
0585            assert(subRange.startIndex >= 0 && subRange.endIndex <= buffer.count)
0586            guard subRange.count > 0 else { return }
0587            openGapAt(index, length: subRange.count)
0588    
0589            let dp = self.elements
0590            let sp = buffer.elements
0591    
0592            let dstStart = self.bufferIndexForDequeIndex(index)
0593            let srcStart = buffer.bufferIndexForDequeIndex(subRange.startIndex)
0594    
0595            let srcCount = subRange.count
0596    
0597            let dstEnd = self.bufferIndexForDequeIndex(index + srcCount)
0598            let srcEnd = buffer.bufferIndexForDequeIndex(subRange.endIndex)
0599    
0600            if srcStart < srcEnd && dstStart < dstEnd {
0601                dp.advancedBy(dstStart).initializeFrom(sp.advancedBy(srcStart), count: srcCount)
0602            }
0603            else if dstStart < dstEnd {
0604                let t = buffer.capacity - srcStart
0605                dp.advancedBy(dstStart).initializeFrom(sp.advancedBy(srcStart), count: t)
0606                dp.advancedBy(dstStart + t).initializeFrom(sp, count: srcCount - t)
0607            }
0608            else if srcStart < srcEnd {
0609                let t = self.capacity - dstStart
0610                dp.advancedBy(dstStart).initializeFrom(sp.advancedBy(srcStart), count: t)
0611                dp.initializeFrom(sp.advancedBy(srcStart + t), count: srcCount - t)
0612            }
0613            else {
0614                let st = buffer.capacity - srcStart
0615                let dt = self.capacity - dstStart
0616    
0617                if dt < st {
0618                    dp.advancedBy(dstStart).initializeFrom(sp.advancedBy(srcStart), count: dt)
0619                    dp.initializeFrom(sp.advancedBy(srcStart + dt), count: st - dt)
0620                    dp.advancedBy(st - dt).initializeFrom(sp, count: srcCount - st)
0621                }
0622                else if dt > st {
0623                    dp.advancedBy(dstStart).initializeFrom(sp.advancedBy(srcStart), count: st)
0624                    dp.advancedBy(dstStart + st).initializeFrom(sp, count: dt - st)
0625                    dp.initializeFrom(sp.advancedBy(dt - st), count: srcCount - dt)
0626                }
0627                else {
0628                    dp.advancedBy(dstStart).initializeFrom(sp.advancedBy(srcStart), count: st)
0629                    dp.initializeFrom(sp, count: srcCount - st)
0630                }
0631            }
0632        }
0633    
0634        internal func insertContentsOfDeque.swift:122         buffer.insertContentsOf(elements, at: 0)
Deque.swift:175             b.insertContentsOf(newElements, at: b.count)
Deque.swift:227         buffer.insertContentsOf(newElements, at: i)<C: CollectionType where C.Generator.Element == Element>(collection: C, at index: Int) {
0635            assert(index >= 0 && index <= count)
0636            let c: Int = numericCast(collection.count)
0637            assert(count + c <= capacity)
0638            guard c > 0 else { return }
0639            openGapAt(index, length: c)
0640            var q = elements.advancedBy(bufferIndexForDequeIndex(index))
0641            let limit = elements.advancedBy(capacity)
0642            for element in collection {
0643                q.initialize(element)
0644                q = q.successor()
0645                if q == limit {
0646                    q = elements
0647                }
0648            }
0649        }
0650    
0651        /// Destroy elements in the range (index ..< index + count) and collapse the gap by moving remaining elements.
0652        /// Note that all previously calculated buffer indexes are invalidated by this method.
0653        private func removeRangeDeque.swift:237         buffer.removeRange(i...i)
Deque.swift:256         buffer.removeRange(0 ..< n)
Deque.swift:265         buffer.removeRange(range)
Deque.swift:273             buffer.removeRange(0..<count)
Deque.swift:299         buffer.removeRange(c - n ..< c)
Deque.swift:782             removeRange(range.startIndex + common ..< range.endIndex)(range: Range<Int>) {
0654            assert(range.startIndex >= 0)
0655            assert(range.endIndex <= self.count)
0656            guard range.count > 0 else { return }
0657            let rc = range.count
0658            let p = elements
0659            let i = bufferIndexForDequeIndex(range.startIndex)
0660            let j = i + rc <= capacity ? i + rc : i + rc - capacity
0661    
0662            // Destroy items in collapsed range
0663            if i <= j {
0664                // ....ABC̲D̲E̲FG...
0665                p.advancedBy(i).destroy(rc)
0666                // ....AB...FG...
0667            }
0668            else {
0669                // D̲E̲FG.......ABC̲
0670                p.advancedBy(i).destroy(capacity - i)
0671                // D̲E̲FG.......AB.
0672                p.destroy(j)
0673                // ..FG.......AB.
0674            }
0675    
0676            if count - range.startIndex - rc < range.startIndex {
0677                let end = start + count < capacity ? start + count : start + count - capacity
0678    
0679                // Slide trailing items to the left
0680                if i <= end { // No wrap anywhere after start of collapsed range
0681                    // ....AB.̲..CD...
0682                    p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc), count: end - i - rc)
0683                    // ....ABC̲D......
0684                }
0685                else if i + rc > capacity { // Collapsed range is wrapped
0686                    if end <= rc { // Result will not be wrapped
0687                        // .CD......AB.̲..
0688                        p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity + end - i - rc)
0689                        // .........ABC̲D.
0690                    }
0691                    else { // Result will remain wrapped
0692                        // .CDEFG...AB.̲..
0693                        p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity - i)
0694                        // ....FG...ABC̲DE
0695                        p.moveInitializeFrom(p.advancedBy(rc), count: end - rc)
0696                        // FG.......ABC̲DE
0697                    }
0698                }
0699                else { // Wrap is after collapsed range
0700                    if end <= rc { // Result will not be wrapped
0701                        // D.......AB.̲..C
0702                        p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc), count: capacity - i - rc)
0703                        // D.......ABC̲...
0704                        p.advancedBy(capacity - rc).moveInitializeFrom(p, count: end)
0705                        // ........ABC̲D..
0706                    }
0707                    else { // Result will remain wrapped
0708                        // DEFG....AB.̲..C
0709                        p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc), count: capacity - i - rc)
0710                        // DEFG....ABC̲...
0711                        p.advancedBy(capacity - rc).moveInitializeFrom(p, count: rc)
0712                        // ...G....ABC̲DEF
0713                        p.moveInitializeFrom(p.advancedBy(rc), count: end - rc)
0714                        // G.......ABC̲DEF
0715                    }
0716                }
0717                count -= rc
0718            }
0719            else {
0720                // Slide preceding items to the right
0721                if j >= start { // No wrap anywhere before end of collapsed range
0722                    // ...AB...C̲D...
0723                    p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: j - start - rc)
0724                    // ......ABC̲D...
0725                }
0726                else if j < rc { // Collapsed range is wrapped
0727                    if  start + rc >= capacity  { // Result will not be wrapped
0728                        // ...C̲D.....AB..
0729                        p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
0730                        // .ABC̲D.........
0731                    }
0732                    else { // Result will remain wrapped
0733                        // ..E̲F.....ABCD..
0734                        p.moveInitializeFrom(p.advancedBy(capacity - rc), count: j)
0735                        // CDE̲F.....AB....
0736                        p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
0737                        // CDE̲F.........AB
0738                    }
0739                }
0740                else { // Wrap is before collapsed range
0741                    if capacity - start <= rc { // Result will not be wrapped
0742                        // CD...E̲F.....AB
0743                        p.advancedBy(rc).moveInitializeBackwardFrom(p, count: j - rc)
0744                        // ...CDE̲F.....AB
0745                        p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
0746                        // .ABCDE̲F.......
0747                    }
0748                    else { // Result will remain wrapped
0749                        // EF...G̲H...ABCD
0750                        p.advancedBy(rc).moveInitializeBackwardFrom(p, count: j - rc)
0751                        // ...EFG̲H...ABCD
0752                        p.moveInitializeFrom(p.advancedBy(capacity) - rc, count: rc)
0753                        // BCDEFG̲H...A...
0754                        p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
0755                        // BCDEFG̲H......A
0756                    }
0757                }
0758                start = (start + rc < capacity ? start + rc : start + rc - capacity)
0759                count -= rc
0760            }
0761        }
0762    
0763        internal func replaceRangeDeque.swift:170             buffer.replaceRange(range, with: newElements)<C: CollectionType where C.Generator.Element == Element>(range: Range<Int>, with newElements: C) {
0764            let newCount: Int = numericCast(newElements.count)
0765            let delta = newCount - range.count
0766            assert(count + delta < capacity)
0767            let common = min(range.count, newCount)
0768            if common > 0 {
0769                let p = elements
0770                var q = p.advancedBy(bufferIndexForDequeIndex(range.startIndex))
0771                let limit = p.advancedBy(capacity)
0772                var i = common
0773                for element in newElements {
0774                    q.memory = element
0775                    q = q.successor()
0776                    if q == limit { q = p }
0777                    i -= 1
0778                    if i == 0 { break }
0779                }
0780            }
0781            if range.count > common {
0782                removeRange(range.startIndex + common ..< range.endIndex)
0783            }
0784            else if newCount > common {
0785                openGapAt(range.startIndex + common, length: newCount - common)
0786                let p = elements
0787                var q = p.advancedBy(bufferIndexForDequeIndex(range.startIndex + common))
0788                let limit = p.advancedBy(capacity)
0789                var i = newElements.startIndex.advancedBy(numericCast(common))
0790                while i != newElements.endIndex {
0791                    q.initialize(newElements[i])
0792                    i = i.successor()
0793                    q = q.successor()
0794                    if q == limit { q = p }
0795                }
0796            }
0797        }
0798    }
0799    
0800    //MARK: 
0801    
0802    extension DequeBuffer {
0803        internal func forEachDeque.swift:829             try buffer.forEach(body)(@noescape body: (Element) throws -> ()) rethrows {
0804            if start + count <= capacity {
0805                var p = elements + start
0806                for _ in 0 ..< count {
0807                    try body(p.memory)
0808                    p += 1
0809                }
0810            }
0811            else {
0812                var p = elements + start
0813                for _ in start ..< capacity {
0814                    try body(p.memory)
0815                    p += 1
0816                }
0817                p = elements
0818                for _ in 0 ..< start + count - capacity {
0819                    try body(p.memory)
0820                    p += 1
0821                }
0822            }
0823        }
0824    }
0825    
0826    extension Deque {
0827        public func forEachDeque.swift:836         try self.forEach { result.append(try transform($0)) }
Deque.swift:842         try self.forEach {
Deque.swift:852         try self.forEach {
Deque.swift:860         try self.forEach {
Deque.swift:870         try self.forEach {(@noescape body: (Element) throws -> ()) rethrows {
0828            try withExtendedLifetime(buffer) { buffer in
0829                try buffer.forEach(body)
0830            }
0831        }
0832    
0833        public func map<T>(@noescape transform: (Element) throws -> T) rethrows -> [T] {
0834            var result: [T] = []
0835            result.reserveCapacity(self.count)
0836            try self.forEach { result.append(try transform($0)) }
0837            return result
0838        }
0839    
0840        public func flatMap<T>(@noescape transform: (Element) throws -> T?) rethrows -> [T] {
0841            var result: [T] = []
0842            try self.forEach {
0843                if let r = try transform($0) {
0844                    result.append(r)
0845                }
0846            }
0847            return result
0848        }
0849    
0850        public func flatMap<S: SequenceType>(transform: (Element) throws -> S) rethrows -> [S.Generator.Element] {
0851            var result: [S.Generator.Element] = []
0852            try self.forEach {
0853                result.appendContentsOf(try transform($0))
0854            }
0855            return result
0856        }
0857    
0858        public func filter(@noescape includeElement: (Element) throws -> Bool) rethrows -> [Element] {
0859            var result: [Element] = []
0860            try self.forEach {
0861                if try includeElement($0) {
0862                    result.append($0)
0863                }
0864            }
0865            return result
0866        }
0867    
0868        public func reduce<T>(initial: T, @noescape combine: (T, Element) throws -> T) rethrows -> T {
0869            var result = initial
0870            try self.forEach {
0871                result = try combine(result, $0)
0872            }
0873            return result
0874        }
0875    }
0876    
0877

Deque.swift:46	extension Deque {
Deque.swift:84	extension Deque: MutableCollectionType {
Deque.swift:86	public typealias Generator = IndexingGenerator<Deque<Element>>
Deque.swift:87	public typealias SubSequence = MutableSlice<Deque<Element>>
Deque.swift:119	extension Deque: ArrayLiteralConvertible {
Deque.swift:128	extension Deque: CustomStringConvertible, CustomDebugStringConvertible {
Deque.swift:131	var result = debug ? "\(String(reflecting: Deque.self))([" : "Deque["
Deque.swift:160	extension Deque: RangeReplaceableCollectionType {
Deque.swift:282	extension Deque {
Deque.swift:328	func == <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:328	func == <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:343	func != <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:343	func != <Element: Equatable>(a: Deque<Element>, b: Deque<Element>) -> Bool {
Deque.swift:826	extension Deque {

Deque.swift:21	internal private(set) var buffer: DequeBuffer<Element>
Deque.swift:33	public init<S: SequenceType where S.Generator.Element == Element>(_ elements: S) {
Deque.swift:39	public init(count: Int, repeatedValue: Element) {

Deque.swift:25	buffer = DequeBuffer()
Deque.swift:29	buffer = DequeBuffer(capacity: minimumCapacity)
Deque.swift:40	buffer = DequeBuffer(count: count, repeatedValue: repeatedValue)
Deque.swift:48	var capacity: Int { return buffer.capacity }
Deque.swift:57	guard buffer.capacity < minimumCapacity else { return }
Deque.swift:58	if isUniquelyReferenced(&buffer) {
Deque.swift:59	buffer = buffer.realloc(minimumCapacity)
Deque.swift:59	buffer = buffer.realloc(minimumCapacity)
Deque.swift:63	new.insertContentsOf(buffer, at: 0)
Deque.swift:64	buffer = new
Deque.swift:68	internal var isUnique: Bool { mutating get { return isUniquelyReferenced(&buffer) } }
Deque.swift:71	self.makeUniqueWithCapacity(buffer.capacity)
Deque.swift:75	guard !isUnique \|\| buffer.capacity < capacity else { return }
Deque.swift:77	copy.insertContentsOf(buffer, at: 0)
Deque.swift:78	buffer = copy
Deque.swift:90	public var count: Int { return buffer.count }
Deque.swift:108	return buffer[index]
Deque.swift:112	buffer[index] = value
Deque.swift:121	self.buffer = DequeBuffer(capacity: elements.count)
Deque.swift:122	buffer.insertContentsOf(elements, at: 0)
Deque.swift:170	buffer.replaceRange(range, with: newElements)
Deque.swift:174	b.insertContentsOf(self.buffer, subRange: 0 ..< range.startIndex, at: 0)
Deque.swift:176	b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
Deque.swift:177	buffer = b
Deque.swift:186	buffer.append(newElement)
Deque.swift:192	var capacity = buffer.capacity
Deque.swift:193	var count = buffer.count
Deque.swift:199	capacity = buffer.capacity
Deque.swift:201	var i = buffer.bufferIndexForDequeIndex(count)
Deque.swift:202	let p = buffer.elements
Deque.swift:210	buffer.count = count
Deque.swift:219	buffer.insert(newElement, at: i)
Deque.swift:227	buffer.insertContentsOf(newElements, at: i)
Deque.swift:236	let element = buffer[i]
Deque.swift:237	buffer.removeRange(i...i)
Deque.swift:247	return buffer.popFirst()!
Deque.swift:256	buffer.removeRange(0 ..< n)
Deque.swift:265	buffer.removeRange(range)
Deque.swift:273	buffer.removeRange(0..<count)
Deque.swift:276	buffer = DequeBuffer()
Deque.swift:289	return buffer.popLast()!
Deque.swift:299	buffer.removeRange(c - n ..< c)
Deque.swift:306	return buffer.popFirst()
Deque.swift:313	return buffer.popLast()
Deque.swift:321	buffer.prepend(element)
Deque.swift:331	if count == 0 \|\| a.buffer === b.buffer { return true }
Deque.swift:331	if count == 0 \|\| a.buffer === b.buffer { return true }
Deque.swift:828	try withExtendedLifetime(buffer) { buffer in

Deque.swift:51	guard capacity > self.capacity else { return self.capacity }
Deque.swift:51	guard capacity > self.capacity else { return self.capacity }
Deque.swift:52	return max(capacity, 2 * self.capacity)
Deque.swift:169	if isUnique && count + delta <= capacity {

Deque.swift:173	let b = DequeBuffer<Element>(capacity: grow(count + delta))
Deque.swift:185	makeUniqueWithCapacity(grow(count + 1))
Deque.swift:198	reserveCapacity(grow(count + 1))
Deque.swift:218	makeUniqueWithCapacity(grow(count + 1))
Deque.swift:226	makeUniqueWithCapacity(grow(count + numericCast(newElements.count)))
Deque.swift:320	makeUniqueWithCapacity(grow(count + 1))

Deque.swift:75	guard !isUnique \|\| buffer.capacity < capacity else { return }
Deque.swift:169	if isUnique && count + delta <= capacity {

Deque.swift:71	self.makeUniqueWithCapacity(buffer.capacity)
Deque.swift:185	makeUniqueWithCapacity(grow(count + 1))
Deque.swift:191	makeUniqueWithCapacity(self.count + newElements.underestimateCount())
Deque.swift:218	makeUniqueWithCapacity(grow(count + 1))
Deque.swift:226	makeUniqueWithCapacity(grow(count + numericCast(newElements.count)))
Deque.swift:320	makeUniqueWithCapacity(grow(count + 1))

Deque.swift:94	public var endIndex: Int { return count }
Deque.swift:97	public var isEmpty: Bool { return count == 0 }
Deque.swift:101	precondition(index >= 0 && index < count)
Deque.swift:166	precondition(range.startIndex >= 0 && range.endIndex <= count)
Deque.swift:169	if isUnique && count + delta <= capacity {
Deque.swift:173	let b = DequeBuffer<Element>(capacity: grow(count + delta))
Deque.swift:176	b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
Deque.swift:185	makeUniqueWithCapacity(grow(count + 1))
Deque.swift:191	makeUniqueWithCapacity(self.count + newElements.underestimateCount())
Deque.swift:218	makeUniqueWithCapacity(grow(count + 1))
Deque.swift:226	makeUniqueWithCapacity(grow(count + numericCast(newElements.count)))
Deque.swift:246	precondition(count > 0)
Deque.swift:255	precondition(count >= n)
Deque.swift:264	precondition(range.startIndex >= 0 && range.endIndex <= count)
Deque.swift:273	buffer.removeRange(0..<count)
Deque.swift:288	precondition(count > 0)
Deque.swift:297	let c = count
Deque.swift:320	makeUniqueWithCapacity(grow(count + 1))
Deque.swift:329	let count = a.count
Deque.swift:330	if count != b.count { return false }
Deque.swift:835	result.reserveCapacity(self.count)

Deque.swift:107	checkSubscript(index)
Deque.swift:111	checkSubscript(index)
Deque.swift:234	checkSubscript(i)

Deque.swift:151	return makeDescription(debug: false)
Deque.swift:154	return makeDescription(debug: true)

Deque.swift:21	internal private(set) var buffer: DequeBuffer<Element>
Deque.swift:25	buffer = DequeBuffer()
Deque.swift:29	buffer = DequeBuffer(capacity: minimumCapacity)
Deque.swift:40	buffer = DequeBuffer(count: count, repeatedValue: repeatedValue)
Deque.swift:62	let new = DequeBuffer<Element>(capacity: minimumCapacity)
Deque.swift:76	let copy = DequeBuffer<Element>(capacity: capacity)
Deque.swift:121	self.buffer = DequeBuffer(capacity: elements.count)
Deque.swift:173	let b = DequeBuffer<Element>(capacity: grow(count + delta))
Deque.swift:276	buffer = DequeBuffer()
Deque.swift:395	internal func realloc(capacity: Int) -> DequeBuffer {
Deque.swift:397	let buffer = DequeBuffer(capacity: capacity)
Deque.swift:577	internal func insertContentsOf(buffer: DequeBuffer, at index: Int) {
Deque.swift:581	internal func insertContentsOf(buffer: DequeBuffer, subRange: Range<Int>, at index: Int) {
Deque.swift:802	extension DequeBuffer {

Deque.swift:352	internal private(set) var elements: UnsafeMutablePointer<Element>
Deque.swift:369	internal convenience init(count: Int, repeatedValue: Element) {
Deque.swift:444	internal func prepend(element: Element) {
Deque.swift:452	internal func popFirst() -> Element? {
Deque.swift:460	internal func append(element: Element) {
Deque.swift:467	internal func popLast() -> Element? {
Deque.swift:570	internal func insert(element: Element, at index: Int) {
Deque.swift:634	internal func insertContentsOf<C: CollectionType where C.Generator.Element == Element>(collection: C, at index: Int) {
Deque.swift:763	internal func replaceRange<C: CollectionType where C.Generator.Element == Element>(range: Range<Int>, with newElements: C) {

Deque.swift:202	let p = buffer.elements
Deque.swift:363	self.elements = UnsafeMutablePointer.alloc(capacity)
Deque.swift:371	let p = elements
Deque.swift:382	let p = self.elements
Deque.swift:399	let dst = buffer.elements
Deque.swift:400	let src = self.elements
Deque.swift:435	return elements.advancedBy(i).memory
Deque.swift:440	elements.advancedBy(i).memory = newValue
Deque.swift:447	elements.advancedBy(i).initialize(element)
Deque.swift:454	let first = elements.advancedBy(start).move()
Deque.swift:463	elements.advancedBy(endIndex).initialize(element)
Deque.swift:470	let last = elements.advancedBy(lastIndex).move()
Deque.swift:490	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: end - i)
Deque.swift:490	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: end - i)
Deque.swift:495	elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:495	elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:497	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:497	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:502	elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: end - i)
Deque.swift:502	elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: end - i)
Deque.swift:509	elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:509	elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:511	elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: length)
Deque.swift:511	elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: length)
Deque.swift:513	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:513	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:518	elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:518	elements.advancedBy(length).moveInitializeBackwardFrom(elements, count: end)
Deque.swift:520	elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:520	elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:531	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:531	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:536	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:536	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:538	elements.moveInitializeFrom(elements.advancedBy(length), count: i - length)
Deque.swift:538	elements.moveInitializeFrom(elements.advancedBy(length), count: i - length)
Deque.swift:543	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:543	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:550	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:550	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:552	elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: length)
Deque.swift:552	elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: length)
Deque.swift:554	elements.moveInitializeFrom(elements.advancedBy(i - length), count: i - length)
Deque.swift:554	elements.moveInitializeFrom(elements.advancedBy(i - length), count: i - length)
Deque.swift:559	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:561	elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: i)
Deque.swift:561	elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: i)
Deque.swift:574	elements.advancedBy(i).initialize(element)
Deque.swift:589	let dp = self.elements
Deque.swift:590	let sp = buffer.elements
Deque.swift:640	var q = elements.advancedBy(bufferIndexForDequeIndex(index))
Deque.swift:641	let limit = elements.advancedBy(capacity)
Deque.swift:646	q = elements
Deque.swift:658	let p = elements
Deque.swift:769	let p = elements
Deque.swift:786	let p = elements
Deque.swift:805	var p = elements + start
Deque.swift:812	var p = elements + start
Deque.swift:817	p = elements

Deque.swift:48	var capacity: Int { return buffer.capacity }
Deque.swift:57	guard buffer.capacity < minimumCapacity else { return }
Deque.swift:71	self.makeUniqueWithCapacity(buffer.capacity)
Deque.swift:75	guard !isUnique \|\| buffer.capacity < capacity else { return }
Deque.swift:192	var capacity = buffer.capacity
Deque.swift:199	capacity = buffer.capacity
Deque.swift:364	self.capacity = capacity
Deque.swift:383	if start + count <= capacity {
Deque.swift:387	let c = capacity - start
Deque.swift:391	p.dealloc(capacity)
Deque.swift:396	if capacity <= self.capacity { return self }
Deque.swift:401	if self.start + self.count <= self.capacity {
Deque.swift:405	let c = self.capacity - self.start
Deque.swift:417	if i >= capacity { return i - capacity }
Deque.swift:417	if i >= capacity { return i - capacity }
Deque.swift:426	return capacity - start + i
Deque.swift:429	internal var isFull: Bool { return count == capacity }
Deque.swift:445	precondition(count < capacity)
Deque.swift:446	let i = start == 0 ? capacity - 1 : start - 1
Deque.swift:461	precondition(count < capacity)
Deque.swift:481	assert(count + length <= capacity)
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:488	if end + length <= capacity { // Neither gap nor elements after it will be wrapped
Deque.swift:493	else if i + length <= capacity { // Elements after gap will be wrapped
Deque.swift:495	elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:495	elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: end + length - capacity)
Deque.swift:497	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:502	elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: end - i)
Deque.swift:507	if i + length <= capacity { // Gap will not be wrapped
Deque.swift:511	elements.moveInitializeFrom(elements.advancedBy(capacity - length), count: length)
Deque.swift:513	elements.advancedBy(i + length).moveInitializeBackwardFrom(elements.advancedBy(i), count: capacity - i - length)
Deque.swift:520	elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:520	elements.advancedBy(i + length - capacity).moveInitializeFrom(elements.advancedBy(i), count: capacity - i)
Deque.swift:536	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:543	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:550	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:552	elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: length)
Deque.swift:559	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:561	elements.advancedBy(capacity - length).moveInitializeFrom(elements, count: i)
Deque.swift:565	start = start < length ? capacity + start - length : start - length
Deque.swift:584	assert(count + subRange.count <= capacity)
Deque.swift:604	let t = buffer.capacity - srcStart
Deque.swift:609	let t = self.capacity - dstStart
Deque.swift:614	let st = buffer.capacity - srcStart
Deque.swift:615	let dt = self.capacity - dstStart
Deque.swift:637	assert(count + c <= capacity)
Deque.swift:641	let limit = elements.advancedBy(capacity)
Deque.swift:660	let j = i + rc <= capacity ? i + rc : i + rc - capacity
Deque.swift:660	let j = i + rc <= capacity ? i + rc : i + rc - capacity
Deque.swift:670	p.advancedBy(i).destroy(capacity - i)
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:685	else if i + rc > capacity { // Collapsed range is wrapped
Deque.swift:688	p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity + end - i - rc)
Deque.swift:688	p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity + end - i - rc)
Deque.swift:693	p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity - i)
Deque.swift:693	p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc - capacity), count: capacity - i)
Deque.swift:702	p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc), count: capacity - i - rc)
Deque.swift:704	p.advancedBy(capacity - rc).moveInitializeFrom(p, count: end)
Deque.swift:709	p.advancedBy(i).moveInitializeFrom(p.advancedBy(i + rc), count: capacity - i - rc)
Deque.swift:711	p.advancedBy(capacity - rc).moveInitializeFrom(p, count: rc)
Deque.swift:727	if start + rc >= capacity { // Result will not be wrapped
Deque.swift:729	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:729	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:734	p.moveInitializeFrom(p.advancedBy(capacity - rc), count: j)
Deque.swift:736	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:741	if capacity - start <= rc { // Result will not be wrapped
Deque.swift:745	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:745	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:752	p.moveInitializeFrom(p.advancedBy(capacity) - rc, count: rc)
Deque.swift:754	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:758	start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758	start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:766	assert(count + delta < capacity)
Deque.swift:771	let limit = p.advancedBy(capacity)
Deque.swift:788	let limit = p.advancedBy(capacity)
Deque.swift:804	if start + count <= capacity {
Deque.swift:813	for _ in start ..< capacity {
Deque.swift:818	for _ in 0 ..< start + count - capacity {

Deque.swift:90	public var count: Int { return buffer.count }
Deque.swift:175	b.insertContentsOf(newElements, at: b.count)
Deque.swift:176	b.insertContentsOf(self.buffer, subRange: range.endIndex ..< count, at: b.count)
Deque.swift:193	var count = buffer.count
Deque.swift:210	buffer.count = count
Deque.swift:365	self.count = 0
Deque.swift:372	self.count = count
Deque.swift:383	if start + count <= capacity {
Deque.swift:384	p.advancedBy(start).destroy(count)
Deque.swift:389	p.destroy(count - c)
Deque.swift:398	buffer.count = self.count
Deque.swift:398	buffer.count = self.count
Deque.swift:401	if self.start + self.count <= self.capacity {
Deque.swift:402	dst.moveInitializeFrom(src.advancedBy(start), count: count)
Deque.swift:407	dst.advancedBy(c).moveInitializeFrom(src, count: self.count - c)
Deque.swift:409	self.count = 0
Deque.swift:429	internal var isFull: Bool { return count == capacity }
Deque.swift:433	assert(index >= 0 && index < count)
Deque.swift:438	assert(index >= 0 && index < count)
Deque.swift:445	precondition(count < capacity)
Deque.swift:449	self.count += 1
Deque.swift:453	guard count > 0 else { return nil }
Deque.swift:456	self.count -= 1
Deque.swift:461	precondition(count < capacity)
Deque.swift:462	let endIndex = bufferIndexForDequeIndex(count)
Deque.swift:464	self.count += 1
Deque.swift:468	guard count > 0 else { return nil }
Deque.swift:469	let lastIndex = bufferIndexForDequeIndex(count - 1)
Deque.swift:471	self.count -= 1
Deque.swift:480	assert(index >= 0 && index <= self.count)
Deque.swift:481	assert(count + length <= capacity)
Deque.swift:484	if index >= (count + 1) / 2 {
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:524	count += length
Deque.swift:566	count += length
Deque.swift:571	precondition(index >= 0 && index <= count && !isFull)
Deque.swift:578	self.insertContentsOf(buffer, subRange: 0 ..< buffer.count, at: index)
Deque.swift:583	assert(index >= 0 && index <= count)
Deque.swift:584	assert(count + subRange.count <= capacity)
Deque.swift:585	assert(subRange.startIndex >= 0 && subRange.endIndex <= buffer.count)
Deque.swift:635	assert(index >= 0 && index <= count)
Deque.swift:637	assert(count + c <= capacity)
Deque.swift:655	assert(range.endIndex <= self.count)
Deque.swift:676	if count - range.startIndex - rc < range.startIndex {
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:717	count -= rc
Deque.swift:759	count -= rc
Deque.swift:766	assert(count + delta < capacity)
Deque.swift:804	if start + count <= capacity {
Deque.swift:806	for _ in 0 ..< count {
Deque.swift:818	for _ in 0 ..< start + count - capacity {

Deque.swift:366	self.start = 0
Deque.swift:383	if start + count <= capacity {
Deque.swift:384	p.advancedBy(start).destroy(count)
Deque.swift:387	let c = capacity - start
Deque.swift:388	p.advancedBy(start).destroy(c)
Deque.swift:401	if self.start + self.count <= self.capacity {
Deque.swift:402	dst.moveInitializeFrom(src.advancedBy(start), count: count)
Deque.swift:405	let c = self.capacity - self.start
Deque.swift:406	dst.moveInitializeFrom(src.advancedBy(self.start), count: c)
Deque.swift:416	let i = start + index
Deque.swift:423	if i >= start {
Deque.swift:424	return i - start
Deque.swift:426	return capacity - start + i
Deque.swift:446	let i = start == 0 ? capacity - 1 : start - 1
Deque.swift:446	let i = start == 0 ? capacity - 1 : start - 1
Deque.swift:448	self.start = i
Deque.swift:454	let first = elements.advancedBy(start).move()
Deque.swift:455	self.start = bufferIndexForDequeIndex(1)
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:486	let end = start + count <= capacity ? start + count : start + count - capacity
Deque.swift:528	if i >= start { // Elements before index are not yet wrapped.
Deque.swift:529	if start >= length { // Neither gap nor elements before it will be wrapped.
Deque.swift:531	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:531	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:531	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:536	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:536	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:536	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: length - start)
Deque.swift:543	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:543	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:543	elements.advancedBy(capacity + start - length).moveInitializeFrom(elements.advancedBy(start), count: i - start)
Deque.swift:550	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:550	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:550	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:559	elements.advancedBy(start - length).moveInitializeFrom(elements.advancedBy(start), count: capacity - start)
Deque.swift:565	start = start < length ? capacity + start - length : start - length
Deque.swift:565	start = start < length ? capacity + start - length : start - length
Deque.swift:565	start = start < length ? capacity + start - length : start - length
Deque.swift:565	start = start < length ? capacity + start - length : start - length
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:677	let end = start + count < capacity ? start + count : start + count - capacity
Deque.swift:721	if j >= start { // No wrap anywhere before end of collapsed range
Deque.swift:723	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: j - start - rc)
Deque.swift:723	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: j - start - rc)
Deque.swift:723	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: j - start - rc)
Deque.swift:727	if start + rc >= capacity { // Result will not be wrapped
Deque.swift:729	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:729	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:729	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity + j - start - rc)
Deque.swift:736	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:736	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:736	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:741	if capacity - start <= rc { // Result will not be wrapped
Deque.swift:745	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:745	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:745	p.advancedBy(start + rc - capacity).moveInitializeFrom(p.advancedBy(start), count: capacity - start)
Deque.swift:754	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:754	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:754	p.advancedBy(start + rc).moveInitializeBackwardFrom(p.advancedBy(start), count: capacity - start - rc)
Deque.swift:758	start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758	start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758	start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:758	start = (start + rc < capacity ? start + rc : start + rc - capacity)
Deque.swift:804	if start + count <= capacity {
Deque.swift:805	var p = elements + start
Deque.swift:812	var p = elements + start
Deque.swift:813	for _ in start ..< capacity {
Deque.swift:818	for _ in 0 ..< start + count - capacity {

Deque.swift:201	var i = buffer.bufferIndexForDequeIndex(count)
Deque.swift:434	let i = bufferIndexForDequeIndex(index)
Deque.swift:439	let i = bufferIndexForDequeIndex(index)
Deque.swift:455	self.start = bufferIndexForDequeIndex(1)
Deque.swift:462	let endIndex = bufferIndexForDequeIndex(count)
Deque.swift:469	let lastIndex = bufferIndexForDequeIndex(count - 1)
Deque.swift:483	let i = bufferIndexForDequeIndex(index)
Deque.swift:573	let i = bufferIndexForDequeIndex(index)
Deque.swift:592	let dstStart = self.bufferIndexForDequeIndex(index)
Deque.swift:593	let srcStart = buffer.bufferIndexForDequeIndex(subRange.startIndex)
Deque.swift:597	let dstEnd = self.bufferIndexForDequeIndex(index + srcCount)
Deque.swift:598	let srcEnd = buffer.bufferIndexForDequeIndex(subRange.endIndex)
Deque.swift:640	var q = elements.advancedBy(bufferIndexForDequeIndex(index))
Deque.swift:659	let i = bufferIndexForDequeIndex(range.startIndex)
Deque.swift:770	var q = p.advancedBy(bufferIndexForDequeIndex(range.startIndex))
Deque.swift:787	var q = p.advancedBy(bufferIndexForDequeIndex(range.startIndex + common))

Deque.swift:108	return buffer[index]
Deque.swift:112	buffer[index] = value
Deque.swift:236	let element = buffer[i]

Deque.swift:247	return buffer.popFirst()!
Deque.swift:306	return buffer.popFirst()

Deque.swift:289	return buffer.popLast()!
Deque.swift:313	return buffer.popLast()

Deque.swift:572	openGapAt(index, length: 1)
Deque.swift:587	openGapAt(index, length: subRange.count)
Deque.swift:639	openGapAt(index, length: c)
Deque.swift:785	openGapAt(range.startIndex + common, length: newCount - common)

Deque.swift:63	new.insertContentsOf(buffer, at: 0)
Deque.swift:77	copy.insertContentsOf(buffer, at: 0)

Deque.swift:122	buffer.insertContentsOf(elements, at: 0)
Deque.swift:175	b.insertContentsOf(newElements, at: b.count)
Deque.swift:227	buffer.insertContentsOf(newElements, at: i)

Deque.swift:237	buffer.removeRange(i...i)
Deque.swift:256	buffer.removeRange(0 ..< n)
Deque.swift:265	buffer.removeRange(range)
Deque.swift:273	buffer.removeRange(0..<count)
Deque.swift:299	buffer.removeRange(c - n ..< c)
Deque.swift:782	removeRange(range.startIndex + common ..< range.endIndex)

Deque.swift:836	try self.forEach { result.append(try transform($0)) }
Deque.swift:842	try self.forEach {
Deque.swift:852	try self.forEach {
Deque.swift:860	try self.forEach {
Deque.swift:870	try self.forEach {