anchor.diff:      let mutable count = 0
   
       let bufferHandles = NativePtr.allocArray [| V3i(buffer.Handle, bbuffer.Handle, count) |]
  -    let indirectHandle = NativePtr.allocArray [| V2i(buffer.Handle, 0) |]
  +    let indirectHandle = NativePtr.allocArray [| V2i(buffer.Handle, count) |]
       let computeSize = NativePtr.allocArray [| V3i.Zero |]
   
       let updatePointers() =
  
positive.code:     member x.Count = count
  
      member x.Add(call : DrawCallInfo, box : Box3d, cellBounds : Box3d, rootId : int) =
          if drawIndices.ContainsKey call then
              false
          else
              if count < capacity then
                  let id = count
                  drawIndices.[call] <- id
                  NativePtr.set mem id (adjust call)
                  if bounds then
                      let bounds =
                          CullingShader.CullingInfo(
                              Min = V4f(V3f box.Min, float32 call.InstanceCount),
                              Max = V4f(V3f box.Max, float32 rootId),
                              CellMin = V4f(V3f cellBounds.Min, 0.0f),
                              CellMax = V4f(V3f cellBounds.Max, 0.0f)
                          )
                      NativePtr.set bmem id bounds
                  count <- count + 1
                  let ess = if bounds then es + bs else es
                  Interlocked.Add(&usedMemory.contents, int64 ess) |> ignore
                  dirty <- RangeSet.insert (Range1i(id,id)) dirty
                      
                  updatePointers()
                  true
              else
                  resize (count + 1)
                  x.Add(call, box, cellBounds, rootId)
                   
      member x.Contains (call : DrawCallInfo) =
          drawIndices.ContainsKey call
  
      member x.Remove(call : DrawCallInfo) =
          match drawIndices.TryRemove call with
              | (true, oid) ->
                  let last = count - 1
                  count <- count - 1
                  let ess = if bounds then es + bs else es
                  Interlocked.Add(&usedMemory.contents, int64 -ess) |> ignore
  
  
negative.code:         NativePtr.allocArray [| new DrawCallInfoList(1, pCall) |]
  
      let resize (newCount : int) =
          let newCapacity = max initialCapacity (Fun.NextPowerOfTwo (max 1 newCount))
          if newCapacity <> capacity then
              let ess = if bounds then es + bs else es
              Interlocked.Add(&totalMemory.contents, int64 (ess * (newCapacity - capacity))) |> ignore
  