anchor.diff:              // so let's put a limit of its interval.
               let renderAcc = 
                   match gl.RenderAccumulator with
  -                | x when x > gl.RenderInterval -> gl.RenderInterval
  +                | x when x > targetRenderInterval -> targetRenderInterval
                   | 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 }
  +                            UpdateAccumulator = gl.UpdateAccumulator - targetUpdateInterval }
                   else
                       gl
   
               let processRender gl =
  -                if gl.RenderAccumulator >= gl.RenderInterval then
  +                if gl.RenderAccumulator >= targetRenderInterval 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
  +                            1, gl.RenderFrameCountTime + (10000L * 1000L), gl.RenderFrameCount
                           else
                               gl.RenderFrameCount + 1, gl.RenderFrameCountTime, gl.RenderFrameLastCount
   
                       { gl with 
                           LastTime = currentTime
  -                        RenderAccumulator = gl.RenderAccumulator - gl.RenderInterval
  +                        RenderAccumulator = gl.RenderAccumulator - targetRenderInterval
                           RenderFrameCount = renderCount
                           RenderFrameCountTime = renderCountTime
                           RenderFrameLastCount = renderLastCount }
  
positive.code:     Native.App.drawVbo (drawLines.Length * sizeof<DrawLine>, drawLines, vbo)
  
  let init () = 
      GCSettings.LatencyMode <- GCLatencyMode.LowLatency
      Native.App.init ()
  
  let exit app = Native.App.exit app
  
negative.code: let makeLines degrees length (line: DrawLine) =
  
      let rec makeLines rads length (lines: DrawLine list) cont = function
          | 15 -> cont lines
          | n ->
              let ldeg = rads + lrad
              let rdeg = rads + rrad
  