anchor.diff:            let entered = enterLockIf syncRoot  isSynchronized
             try
               if this.size > 0 then
  -              index := this.size - 1
  -              currentKey := this.GetKeyByIndex(index.Value)
  -              currentValue := this.values.[index.Value]
  +              index <- this.size - 1
  +              currentKey <- this.GetKeyByIndex(index)
  +              currentValue <- this.values.[index]
                 true
               else
                 p.Reset()
  
positive.code:           finally
              exitLockIf syncRoot entered
  
          member p.CurrentKey with get() = currentKey.Value //if index.Value >= 0 then this.GetKeyByIndex(index.Value) else Unchecked.defaultof<'K> //currentKey.Value
  
          member p.CurrentValue with get() = currentValue.Value //if index.Value >= 0 then this.values.[index.Value] else Unchecked.defaultof<'V> //currentValue.Value
  
        interface IEnumerator<KVP<'K,'V>> with
          member p.Current with get() : KVP<'K,'V> = KeyValuePair(currentKey.Value, currentValue.Value)
          member p.Current with get() : obj = box p.Current
          member p.MoveNext() = 
            let entered = enterLockIf syncRoot isSynchronized
            try
              if cursorVersion.Value =  this.orderVersion then
                if index.Value < (this.size - 1) then
                  index := !index + 1
                  // TODO!! (perf) regular keys were supposed to speed up things, not to slow down by 50%! 
                  currentKey := this.GetKeyByIndexUnchecked(!index)
                  currentValue := this.values.[!index]
                  true
                else
                  //p.Reset() // NB! Do not reset cursor on false MoveNext
                  false
              else  // source change
                cursorVersion :=  this.orderVersion // update state to new this.version
                let mutable kvp = Unchecked.defaultof<_>
                let position = this.TryFindWithIndex(currentKey.Value, Lookup.GT, &kvp) // reposition cursor after source change //currentKey.Value
                if position > 0 then
                  index := position
                  currentKey := kvp.Key
                  currentValue := kvp.Value
                  true
                else  // not found
                  //p.Reset() // NB! Do not reset cursor on false MoveNext
  
negative.code:   // TODO(?) replace with a mutable struct, like in SCG.SortedList<T>, there are too many virtual calls and reference cells in the most critical paths like MoveNext
    // NB Object expression with ref cells are surprisingly fast compared to a custom class or even a struct
    member internal this.GetCursor(index:int,cursorVersion:int,currentKey:'K, currentValue:'V) =
      let mutable index = index
      let mutable cursorVersion = cursorVersion
      let mutable currentKey : 'K = currentKey
      let mutable currentValue : 'V = currentValue
      let mutable isBatch = false
  
      let observerStarted = ref false
      let mutable semaphore : SemaphoreSlim = Unchecked.defaultof<_>
  