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:             c <- Array.tryFind f arrays.[i]
              i <- i + 1
          c
  
      ///Applies a function to each element of the collection, threading an accumulator argument through the computation.
      member this.Fold (folder : 'State -> 'T -> 'State) (state : 'State) : 'State =
          let mutable state = state
          let tail = count % blockSize
          if active > 1
          then            
              for i in 0..active - 2 do
                  state <- Array.fold folder state arrays.[i]            
          let a = arrays.[active - 1]
          for i in 0..tail - 1 do
              state <- folder state a.[i]
          state
              
  
negative.code: 
      ///Applies the given function to each element of the block resize array.
      member this.Iter f =
          if active > 1
          then
              for i = 0 to active - 2 do
                  Array.iter f arrays.[i]
          let a = arrays.[active - 1]
          let top = countTop count
          for i in 0..top do
              f a.[i] 
  
  module BlockeResizeArray = 
  
  