anchor.diff:              let currentTime = time ()
               let deltaTime =
                   match currentTime - gl.LastTime with
  -                | x when x > 1000. / 25. -> 1000. / 25.
  +                | x when x > skip -> skip
                   | x -> x
   
               let accumulator = gl.Accumulator + deltaTime
  
positive.code:     type private GameLoop<'T> = { 
          State: 'T
          PreviousState: 'T
          Time: float
          LastTime: float
          Accumulator: float }
  
      let start (state: 'T) (update: float -> float -> 'T -> 'T) (render: float -> 'T -> 'T -> 'T) =
          let targetInterval = 1000. / 30.
  
          let stopwatch = Stopwatch.StartNew ()
          let inline time () = stopwatch.Elapsed.TotalMilliseconds
  
negative.code:                 then
                      processUpdate
                          { gl with 
                              State = update gl.UpdateTime targetInterval gl.State
                              PreviousState = gl.State
                              UpdateTime = gl.UpdateTime + targetInterval
                              Accumulator = gl.Accumulator - targetInterval }
                  else
                      gl
  
              let processRender gl =
                  { gl with 
                      LastTime = currentTime
                      State = render (gl.Accumulator / targetInterval) gl.PreviousState gl.State }
                           
              { gl with Accumulator = accumulator }
              |> processUpdate
              |> processRender
              |> loop
  
          loop
              { State = state
                PreviousState = state
                UpdateTime = 0.
                LastTime = 0.
                Accumulator = 0. }
  
  