anchor.diff:      member this.Id with get() = this.Id
     //#endregion
   
  +
  +[<AllowNullLiteral>]
  +[<SerializableAttribute>]
  +type SortedChunkedMap<'K,'V>
  +  internal 
  +  (
  +    outerFactory:IComparer<'K>->IOrderedMap<'K, IOrderedMap<'K,'V>>,
  +    innerFactory:int * IComparer<'K>->IOrderedMap<'K,'V>, 
  +    comparer:IComparer<'K>,
  +    hasher:IKeyHasher<'K> option, 
  +    chunkMaxSize:int option) =
  +  inherit SortedChunkedMapGeneric<'K,'V,IOrderedMap<'K,'V>>(outerFactory, innerFactory, comparer, hasher, chunkMaxSize)
  +
     // x0
     
     new() = 
       let comparer:IComparer<'K> = KeyComparer.GetDefault<'K>()
       let factory = (fun (c:IComparer<'K>) -> new SortedMap<'K, IOrderedMap<'K,'V>>(c, IsSynchronized = false) :> IOrderedMap<'K, IOrderedMap<'K,'V>>)
  -    new SortedChunkedMap<_,_>(factory, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>), comparer, None)
  +    new SortedChunkedMap<_,_>(factory, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>), comparer, None, None)
     
     // x1
   
     /// In-memory sorted chunked map
     new(comparer:IComparer<'K>) = 
       let factory = (fun (c:IComparer<'K>) -> new SortedMap<'K, IOrderedMap<'K,'V>>(c, IsSynchronized = false) :> IOrderedMap<'K, IOrderedMap<'K,'V>>)
  -    new SortedChunkedMap<_,_>(factory, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>),comparer, None)
  +    new SortedChunkedMap<_,_>(factory, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>),comparer, None, None)
     
     /// In-memory sorted chunked map
     new(hasher:Func<'K,'K>) = 
  
positive.code:     let hasher = { new IKeyHasher<'K> with
            member x.Hash(k) = hasher.Invoke k
          }
      new SortedChunkedMap<_,_>(outerFactory.Invoke, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>), comparer, Some(hasher))
    
    internal new(outerFactory:Func<IComparer<'K>,IOrderedMap<'K, IOrderedMap<'K,'V>>>,comparer:IComparer<'K>,chunkMaxSize:int) = 
      new SortedChunkedMap<_,_>(outerFactory.Invoke, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>), comparer, None, chunkMaxSize)
  
  
  
  
negative.code:     let hasher = { new IKeyHasher<'K> with
            member x.Hash(k) = hasher.Invoke k
          }
      new SortedChunkedMap<_,_>(factory, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>), comparer, Some(hasher), None)
    new(chunkMaxSize:int) = 
      let factory = (fun (c:IComparer<'K>) -> new SortedMap<'K, IOrderedMap<'K,'V>>(c, IsSynchronized = false) :> IOrderedMap<'K, IOrderedMap<'K,'V>>)
      let comparer:IComparer<'K> = KeyComparer.GetDefault<'K>()
      new SortedChunkedMap<_,_>(factory, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>), comparer, None, Some(chunkMaxSize))
  
    internal new(outerFactory:Func<IComparer<'K>,IOrderedMap<'K, IOrderedMap<'K,'V>>>) = 
      let comparer:IComparer<'K> = KeyComparer.GetDefault<'K>()
      new SortedChunkedMap<_,_>(outerFactory.Invoke, (fun (capacity, comparer) -> new SortedMap<'K,'V>(capacity, comparer) :> IOrderedMap<'K,'V>), comparer, None, None)
    
    // x2
  
  