anchor.diff:      /// Gets the number of elements contained in the Deque.
       member this.Count = count
   
  -    member private this.CopyArray(size) =
  -        let newArray = Array.zeroCreate size
  -
  -        if 0 <> startOffset && startOffset + this.Count >= this.Capacity then
  -            let lengthFromStart = this.Capacity - startOffset
  -            let lengthFromEnd = this.Count - lengthFromStart            
  -
  -            Array.Copy(buffer, startOffset, newArray, 0, lengthFromStart)
  -
  -            Array.Copy(buffer, 0, newArray, lengthFromStart, lengthFromEnd)
  -        else
  -            Array.Copy(buffer, startOffset, newArray, 0, this.Count)
  -        newArray
  -
  -    /// Sets the total number of elements the internal array can hold without resizing.
  -    member private this.DoubleCapacity() =
  -        if capacity < 0 then
  -            raise <| new ArgumentOutOfRangeException("value", "Capacity is less than 0.")
  -
  -        if capacity < this.Count then
  -            raise <| new InvalidOperationException("Capacity cannot be set to a value less than Count")
  -
  -        if capacity <= buffer.Length then () else
  -
  -        // Set up to use the new buffer.
  -        capacity <- capacity * 2
  -        buffer <- this.CopyArray(capacity)
  -        capacityClosestPowerOfTwoMinusOne <- capacity - 1
  -        startOffset <- 0
  -
       member private this.shiftStartOffset(value) =
  -        startOffset <- this.toBufferIndex(value)
  +        startOffset <- toBufferIndex(value)
           startOffset
   
       member private this.preShiftStartOffset(value) =
  
positive.code:     let mutable count = 0
      let mutable capacityClosestPowerOfTwoMinusOne = 0
  
      /// Creates a new Deque with the default capacity
      new() = Deque<'T>(16)
  
  
negative.code:     /// Gets whether or not the Deque is empty.
      member this.IsEmpty = this.Count = 0
  
  
      /// Adds the provided item to the back of the Deque.
      member this.Add(item) =
          if this.Count >= this.Capacity then
              doubleCapacity()
  
          buffer.[toBufferIndex(startOffset + this.Count)] <- item
          count <- count + 1
  
      /// Removes an item from the front of the Deque and returns it.
  