anchor.diff:          State: 'T
           PreviousState: 'T
           LastTime: float
  -        LastRenderTime: float
           UpdateTime: float
  -        Accumulator: float
  +        UpdateAccumulator: float
  +        RenderAccumulator: float
           RenderInterval: float }
   
       let start (state: 'T) (update: float -> float -> 'T -> 'T) (render: float -> 'T -> 'T -> unit) =
  
positive.code:                 | x when x > skip -> skip
                  | x -> x
  
              let acc = gl.Accumulator + deltaTime
  
              let rec processUpdate gl =
                  if gl.Accumulator >= targetUpdateInterval
                  then
                      let state = update gl.UpdateTime targetUpdateInterval gl.State
                      let renderInterval = time () - currentTime
  
negative.code:                             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 (gl.UpdateAccumulator / targetUpdateInterval) gl.PreviousState gl.State
  
                      { gl with 
                          LastTime = currentTime
                          RenderAccumulator = gl.RenderAccumulator - gl.RenderInterval }
                  else
                      { gl with LastTime = currentTime }
                           
              { gl with UpdateAccumulator = updateAcc; RenderAccumulator = renderAcc }
              |> processUpdate
              |> processRender
              |> loop
  