anchor.diff:              let pool = GeometryPool.create()
               let calls = DrawCallSet(true)
               let inactive = ConcurrentHashQueue<GeometryRef>()
  -            let mutable inactiveSize = 0
  -            let mutable activeSize = 0
  +            let mutable inactiveSize = 0L
  +            let mutable activeSize = 0L
   
               let levelCounts = Array.zeroCreate 128
   
  
positive.code:             let deactivate (n : GeometryRef) =
                  calls.Remove n.range |> ignore
                  inactive.Enqueue n |> ignore
                  let size = n.range.Size
                  Interlocked.Add(&inactiveSize, size) |> ignore
                  Interlocked.Add(&activeSize, -size) |> ignore
                  levelCounts.[n.node.level] <- levelCounts.[n.node.level] - 1
  
negative.code:                     async {
                          while true do
                              let mutable cnt = 0
  
                              let shouldPrune () =
                                  if inactiveSize > node.Config.minReuseCount then 
                                      let ratio = float inactiveSize / float (inactiveSize + activeSize)
                                      if ratio > node.Config.maxReuseRatio then true
                                      else false
                                  else
                                      false
  
  
                              while shouldPrune() do
                                  match inactive.TryDequeue() with
                                      | (true, v) ->
                                          ReaderWriterLock.write geometriesRW (fun () ->
                                              match geometries.TryRemove v.node with
                                                  | (true, v) ->
                                                      let r = pool.Remove v.geometry
                                                      Interlocked.Add(&inactiveSize, int64 -v.range.Size) |> ignore
                                                      cnt <- cnt + 1
                                                  | _ ->
                                                      Log.warn "failed to remove node: %A" v.node.id
  