anchor.diff:                UpdateTime = 0L
                 UpdateAccumulator = targetUpdateInterval
                 RenderAccumulator = 0L
  -              RenderInterval = 0L
                 RenderFrameCount = 0
                 RenderFrameCountTime = 0L
                 RenderFrameLastCount = 0 }
  
positive.code:             // so let's put a limit of its interval.
              let renderAcc = 
                  match gl.RenderAccumulator with
                  | x when x > gl.RenderInterval -> gl.RenderInterval
                  | x -> x + deltaTime
  
              let rec processUpdate gl =
                  if gl.UpdateAccumulator >= targetUpdateInterval
                  then
                      let state = update gl.UpdateTime targetUpdateInterval gl.State
                      let renderInterval = time () - currentTime
  
                      let renderInterval =
                          if renderInterval < targetRenderInterval
                          then targetRenderInterval
                          else renderInterval
  
                      processUpdate
                          { gl with 
                              State = state
                              PreviousState = gl.State
                              UpdateTime = gl.UpdateTime + targetUpdateInterval
                              UpdateAccumulator = gl.UpdateAccumulator - targetUpdateInterval
                              RenderInterval = renderInterval }
                  else
                      gl
  
              let processRender gl =
                  if gl.RenderAccumulator >= gl.RenderInterval then
                      render (single gl.UpdateAccumulator / single targetUpdateInterval) gl.PreviousState gl.State
  
                      let renderCount, renderCountTime, renderLastCount =
                          if currentTime >= gl.RenderFrameCountTime + (10000L * 1000L) then
                              printfn "%A" gl.RenderFrameLastCount
                              0, gl.RenderFrameCountTime + (10000L * 1000L), gl.RenderFrameCount
                          else
                              gl.RenderFrameCount + 1, gl.RenderFrameCountTime, gl.RenderFrameLastCount
  
                      { gl with 
                          LastTime = currentTime
                          RenderAccumulator = gl.RenderAccumulator - gl.RenderInterval
                          RenderFrameCount = renderCount
                          RenderFrameCountTime = renderCountTime
                          RenderFrameLastCount = renderLastCount }
  
negative.code:         UpdateTime: int64
          UpdateAccumulator: int64
          RenderAccumulator: int64
          RenderFrameCount: int
          RenderFrameCountTime: int64
          RenderFrameLastCount: int }
  