anchor.diff:      let mutable cap = blockSize * arrays.Length
       let mutable nextAllocate = cap
       let mutable active = 1
  -    
  +
  +    let countTop c = 
  +        let tail = count % blockSize 
  +        if count <> 0 
  +        then if tail = 0 then blockSize - 1 else tail - 1
  +        else -1
  +
       interface IEnumerable<'T> with
           member this.GetEnumerator () =
               let e = 
  
positive.code: 
      ///Applies the given function to each element of the block resize array.
      member this.Iter f =
          for i = 0 to active - 1 do
              Array.iter f arrays.[i] 
  
  module BlockeResizeArray = 
  
  
negative.code:     ///Builds a new block resize array whose elements are the results of applying the given function to each of the elements of the array.
      member this.Map (f : 'T -> 'U) =
          let result = new BlockResizeArray<'U>()
          let arr = Array.zeroCreate<_> active
          if active > 1
          then
              for i = 0 to active - 2 do
                  arr.[i] <- Array.map f arrays.[i]
          let a = arrays.[active - 1]
          let top = countTop count
          for i in 0..top do
              arr.[active - 1].[i] <- f a.[i]
          result.SetArrays arr
          result.setCount count
          result.SetActive active
  