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:         NativePtr.allocArray [| new DrawCallInfoList(1, pCall) |]
  
      let resize (newCount : int) =
          let newCapacity = max initialCapacity (Fun.NextPowerOfTwo newCount)
          if newCapacity <> capacity then
              let ess = if bounds then es + bs else es
              Interlocked.Add(&totalMemory.contents, int64 (ess * (newCapacity - capacity))) |> ignore
  
negative.code:                 false
          
      member x.Flush() =
          
          let toUpload = dirty
          dirty <- RangeSet.empty
  
          let toUpload =
              toUpload |> Seq.choose (fun r ->
                  if r.Max < 0 then
                      Log.warn "bad dirty range: %A" r
                      None
                  elif r.Min >= count then
                      Log.warn "bad dirty range: %A" r
                      None
                  else
                      let mm = count - 1
                      let c = Range1i(clamp 0 mm r.Min, clamp 0 mm r.Max)
                      if c <> r then
                          Log.warn "bad dirty range: %A" r
                      if c.Max >= c.Min then
                          Some c
                      else
                          None
              ) |> Seq.toArray
  
          if toUpload.Length > 0 then
              use __ = ctx.ResourceLock
              let ptr = ctx.MapBufferRange(buffer, 0n, nativeint (count * es), BufferAccessMask.MapWriteBit ||| BufferAccessMask.MapFlushExplicitBit)
              for r in toUpload do
                  let o = r.Min * es |> nativeint
                  let s = (1 + r.Max - r.Min) * es |> nativeint
                  Marshal.Copy(NativePtr.toNativeInt mem + o, ptr + o, s)
                  GL.FlushMappedNamedBufferRange(buffer.Handle, o, s)
              ctx.UnmapBuffer(buffer)
  
              if bounds then
                  let bptr = ctx.MapBufferRange(bbuffer, 0n, nativeint (count * bs), BufferAccessMask.MapWriteBit ||| BufferAccessMask.MapFlushExplicitBit)
                  for r in toUpload do
                      let o = r.Min * bs |> nativeint
                      let s = (1 + r.Max - r.Min) * bs |> nativeint
                      Marshal.Copy(NativePtr.toNativeInt bmem + o, bptr + o, s)
                      GL.FlushMappedNamedBufferRange(bbuffer.Handle, o, s)
                  ctx.UnmapBuffer(bbuffer)
  
  
      member x.Buffer =
  