anchor.diff:            readLockIf &this.nextOrderVersion &this.orderVersion this.isSynchronized (fun _ ->
               if (not this.IsMutable) && (index = -1) then
                 index <- this.size - 1 // at the last element of the batch
  -              currentKey <- this.GetKeyByIndex(index)
  +              currentKey <- this.GetKeyByIndexUnchecked(index)
                 currentValue <- this.values.[index]
                 isBatch <- true
                 trueTask
  
positive.code: 
    //#region Constructors
  
    // TODO try resolve KeyComparer for know types
    new() = SortedMap(None, None, None)
    new(dictionary:IDictionary<'K,'V>) = SortedMap(Some(dictionary), Some(dictionary.Count), None)
    new(minimumCapacity:int) = SortedMap(None, Some(minimumCapacity), None)
  
    // do not expose ctors with comparer to public
    internal new(comparer:IComparer<'K>) = SortedMap(None, None, Some(comparer))
    internal new(dictionary:IDictionary<'K,'V>,comparer:IComparer<'K>) = SortedMap(Some(dictionary), Some(dictionary.Count), Some(comparer))
    internal new(minimumCapacity:int,comparer:IComparer<'K>) = SortedMap(None, Some(minimumCapacity), Some(comparer))
  
    static member internal OfSortedKeysAndValues(keys:'K[], values:'V[], size:int, comparer:IComparer<'K>, sortChecked:bool, isAlreadyRegular) =
      if keys.Length < size && not isAlreadyRegular then raise (new ArgumentException("Keys array is smaller than provided size"))
  
negative.code:           result <- this.GetPairByIndexUnchecked(0)
            0
          else
            let index = this.IndexOfKeyUnchecked(key)
            if index >= 0 && index < this.Count then
              result <- this.GetPairByIndexUnchecked(index) // equal
              index
  