anchor.diff:      let private generatePool (sizeInKB : int, itemsInPool : int) = 
           let factory() = Array.create (sizeInKB * 1024) (0uy)
           let onRelease (item : _) = true
  -        new DefaultObjectPool<byte []>(new DefaultObjectPoolPolicy<byte []>(factory, onRelease))
  +        new DefaultObjectPool<byte []>(new ObjectPoolPolicy<byte []>(factory, onRelease))
       
       let smallPoolSize = 128
       let largePoolSize = 4096
  
positive.code: open System.Collections.Concurrent
  open System.Threading
  
  type DefaultObjectPoolPolicy<'T>(factory : unit -> 'T, onRelease : 'T -> bool) = 
      interface IPooledObjectPolicy<'T> with
          member __.Create() = factory()
          member __.Return(value : 'T) = onRelease (value)
  
negative.code:         let onRelease (dict : Dictionary<string, string>) = 
              dict.Clear()
              true
          new DefaultObjectPool<Dictionary<string, string>>(new ObjectPoolPolicy<Dictionary<string, string>>(factory, 
                                                                                                                onRelease))
      
      /// Global memory pool to be shared across the engine
  