anchor.diff:              raise <| new InvalidOperationException("The Deque is empty")
   
           count <- count - 1
  -        buffer.[this.toBufferIndex(this.Count)]
  +        buffer.[toBufferIndex(this.Count)]
   
       /// Gets the value at the specified index of the Deque
       member this.Get(index) =
           if index >= this.Count then
               raise <| new IndexOutOfRangeException("The supplied index is greater than the Count")
   
  -        buffer.[this.toBufferIndex(index)]
  +        buffer.[toBufferIndex(index)]
   
       /// Gets the element at the front
       member this.First =
           if count = 0 then
               raise <| new InvalidOperationException("The Deque is empty")
   
  -        buffer.[this.toBufferIndex(0)]
  +        buffer.[toBufferIndex(0)]
   
       /// Gets the element at the end
       member this.Last =
           if count = 0 then
               raise <| new InvalidOperationException("The Deque is empty")
   
  -        buffer.[this.toBufferIndex(count - 1)]
  +        buffer.[toBufferIndex(count - 1)]
   
       interface System.Collections.Generic.IEnumerable<'T> with
           member this.GetEnumerator() =
  -          this.iterate().GetEnumerator()
  +          iterate().GetEnumerator()
   
       interface System.Collections.IEnumerable with
           member this.GetEnumerator () =
  -          (this.iterate().GetEnumerator())
  +          (iterate().GetEnumerator())
               :> System.Collections.IEnumerator        
  
positive.code:     /// Gets whether or not the Deque is empty.
      member this.IsEmpty = this.Count = 0
  
      member this.toBufferIndex index =
          (index + startOffset) &&& capacityClosestPowerOfTwoMinusOne
  
      member this.iterate() =
          // The below is done for performance reasons.
          // Rather than doing bounds checking and modulo arithmetic
          // that would go along with calls to Get(index), we can skip
          // all of that by referencing the underlying array.
          seq {
              if startOffset + this.Count > this.Capacity then
              
                  for i in startOffset..this.Capacity-1 do
                      yield buffer.[i]
  
                  let endIndex = this.toBufferIndex(this.Count - startOffset - 1)
  
                  for i in 0..endIndex-1 do
                      yield buffer.[i]           
              else            
                  let endIndex = startOffset + this.Count
                  for i in startOffset .. endIndex-1 do
                      yield buffer.[i]
          }
  
      /// Adds the provided item to the back of the Deque.
      member this.Add(item) =
          if this.Count >= this.Capacity then
              this.DoubleCapacity()
  
          buffer.[this.toBufferIndex(startOffset + this.Count)] <- item
          count <- count + 1
  
      /// Removes an item from the front of the Deque and returns it.
  
negative.code:     /// Gets the number of elements contained in the Deque.
      member this.Count = count
  
      member private this.shiftStartOffset(value) =
          startOffset <- toBufferIndex(value)
          startOffset
  
      member private this.preShiftStartOffset(value) =
  