anchor.diff:          let onRelease (item : List<string>) = 
               item.Clear()
               true
  -        new DefaultObjectPool<List<string>>(new DefaultObjectPoolPolicy<List<string>>(factory, onRelease))
  +        new DefaultObjectPool<List<string>>(new ObjectPoolPolicy<List<string>>(factory, onRelease))
   
   [<AutoOpen>]
   module BytePool = 
  
positive.code:     let releaseBuffer (item : array<byte>) = 
          if item.Length = smallPoolSizeBytes then smallPool.Return(item)
          else 
              if item.Length = largePoolSizeBytes then largePool.Return(item)
  
  open Microsoft.Extensions.ObjectPool
  type TrackingObjectPool<'T when 'T : equality and 'T : not struct> (policy : IPooledObjectPolicy<'T>, maximumRetained : int) =
      let _items : 'T[] = Array.init maximumRetained (fun i -> Unchecked.defaultof<'T>)
      let _policy : IPooledObjectPolicy<'T> = if policy |> isNull 
                                              then raise <| new ArgumentNullException("policy")
                                              else policy
      
      let rec iterator index (array : 'X[] when 'X : equality and 'X : not struct)  = 
          if index >= array.Length then None
          else 
              let item = array.[index]
              if item <> Unchecked.defaultof<'X> 
                 && Interlocked.CompareExchange(ref array.[index], Unchecked.defaultof<'X>, item) = item
              then Some(item)
              else iterator (index + 1) array
  
      let rec replaceFirstNullWith index obj (array : 'X[]) =
          if index >= array.Length then ()
          else
              if array.[index] = Unchecked.defaultof<'X> then array.[index] <- obj
              else replaceFirstNullWith (index + 1) obj array
  
      new (policy : IPooledObjectPolicy<'T>) = TrackingObjectPool(policy, Environment.ProcessorCount * 2)
  
      member __.Get() = 
          match _items |> iterator 0 with
          | Some(item) -> item
          | _ -> _policy.Create()
      member __.Return(t : 'T) =
          if not <| _policy.Return(t) then ()
          else _items |> replaceFirstNullWith 0 t
      member __.GetAll() = _items |> Array.where ((<>) Unchecked.defaultof<'T>)
negative.code:     let private generatePool (sizeInKB : int, itemsInPool : int) = 
          let factory() = Array.create (sizeInKB * 1024) (0uy)
          let onRelease (item : _) = true
          new DefaultObjectPool<byte []>(new ObjectPoolPolicy<byte []>(factory, onRelease))
      
      let smallPoolSize = 128
      let largePoolSize = 4096
  