anchor.diff:            let entered = enterLockIf syncRoot  isSynchronized
             try
               if this.size > 0 then
  -              index := 0
  -              currentKey := this.GetKeyByIndex(index.Value)
  -              currentValue := this.values.[index.Value]
  +              index <- 0
  +              currentKey <- this.GetKeyByIndex(index)
  +              currentValue <- this.values.[index]
                 true
               else
                 p.Reset()
  
positive.code:         member p.MoveNextBatch(cancellationToken: CancellationToken): Task<bool> =
            let entered = enterLockIf syncRoot  isSynchronized
            try
              if (not this.IsMutable) && (!index = -1) then
                index := this.size - 1 // at the last element of the batch
                currentKey := this.GetKeyByIndex(index.Value)
                currentValue := this.values.[!index]
                isBatch := true
                Task.FromResult(true)
              else Task.FromResult(false)
            finally
              exitLockIf syncRoot entered
  
          member p.Clone() = this.GetCursor(!index,!cursorVersion, p.CurrentKey, p.CurrentValue) //!currentKey,!currentValue)
        
          member p.MovePrevious() = 
            let entered = enterLockIf syncRoot  isSynchronized
            try
              if index.Value = -1 then p.MoveLast()  // first move when index = -1
              elif cursorVersion.Value =  this.orderVersion then
                if index.Value > 0 && index.Value < this.size then
                  index := index.Value - 1
                  currentKey := this.GetKeyByIndex(index.Value)
                  currentValue := this.values.[index.Value]
                  true
                else
                  //p.Reset()
                  false
              else
                cursorVersion :=  this.orderVersion // update state to new this.version
                let mutable kvp = Unchecked.defaultof<_>
                let position = this.TryFindWithIndex(p.CurrentKey, Lookup.LT, &kvp) //currentKey.Value
                if position > 0 then
                  index := position
                  currentKey := kvp.Key
                  currentValue := kvp.Value
                  true
                else  // not found
                  //p.Reset()
  
negative.code:           finally
              exitLockIf syncRoot entered
  
          member p.CurrentKey with get() = currentKey
  
          member p.CurrentValue with get() = currentValue
  
        interface IEnumerator<KVP<'K,'V>> with
          member p.Current with get() : KVP<'K,'V> = KeyValuePair(currentKey, currentValue)
          member p.Current with get() : obj = box p.Current
          member p.MoveNext() = 
            let entered = enterLockIf syncRoot isSynchronized
            try
              if cursorVersion =  this.orderVersion then
                if index < (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, 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
  