anchor.diff:              Pipeline (
                   fun context ->
                       context.AddAction (fun () ->
  -                        f input program.Draw
  +                        Backend.useProgram program.programId
  +                        f input (fun () -> program.Run RenderPass.Depth)
  +                        program.Unbind ()
  +                        Backend.useProgram 0
                       )
                       output
               )
  
positive.code: 
          | _ -> false
  
      member this.Draw (time: float32) =
  
          Backend.enableDepth ()
  
          this.finalRenderTexture.TryBufferData () |> ignore
          this.finalRenderTexture.Bind ()
  
          for i = 0 to this.cameraDepths.Length - 1 do
  
              let cameras = this.cameraDepths.[i]
  
              for i = 0 to cameras.Count - 1 do
  
                  let camera = cameras.[i]
  
                  //renderCamera.renderTexture.TryBufferData () |> ignore
  
                  //renderCamera.renderTexture.Bind ()
  
                  if camera.clearFlags.HasFlag (CameraClearFlags.Depth) then
                      Backend.clearDepth ()
  
                  if camera.clearFlags.HasFlag (CameraClearFlags.Color) then
                      Backend.clearColor ()
  
                  if camera.clearFlags.HasFlag (CameraClearFlags.Stencil) then
                      Backend.clearStencil ()
  
                  for i = 0 to this.layerManager.Count - 1 do
                      let mask =
                          match i with
                          | 0 -> CameraLayerFlags.Layer0
                          | 1 -> CameraLayerFlags.Layer1
                          | 2 -> CameraLayerFlags.Layer2
                          | 3 -> CameraLayerFlags.Layer3
                          | 4 -> CameraLayerFlags.Layer4
                          | 5 -> CameraLayerFlags.Layer5
                          | 6 -> CameraLayerFlags.Layer6
                          | _ -> CameraLayerFlags.None
  
                      if camera.layerFlags.HasFlag (mask) then
                          this.layerManager.TryFindById (CompactId (i, 1u))
                          |> Option.iter (fun renderLayer ->
  
                              renderLayer.textureMeshes
                              |> Seq.iter (fun pair ->
                                  let shaderId = pair.Key
                                  let textureLookup = pair.Value
  
                                  let shader, f = this.shaders.[shaderId]
  
                                  Backend.useProgram shader.programId
  
                                  textureLookup
                                  |> Seq.iter (fun pair ->
                                      let texture, bucket = pair.Value
                                      f time camera.view camera.projection texture bucket
                                      shader.Unbind ()
                                  )
  
                                  Backend.useProgram 0
                              )
                          )
  
                  //renderCamera.renderTexture.Unbind ()
  
          //Backend.disableStencilTest ()
          this.finalRenderTexture.Unbind ()
  
  
          Backend.clear ()
  
          Backend.useProgram this.finalShaderProgram.programId
  
  
          this.finalPosition.Set this.finalPositionBuffer
          this.finalTexture.Set this.finalRenderTexture
          this.finalTime.Set time
  
          this.finalShaderProgram.Run RenderPass.Depth
          this.finalShaderProgram.Unbind ()
  
          Backend.useProgram 0
  
          Backend.disableDepth ()
  
  
negative.code:                 context.AddAction (fun () ->
                      renderTexture.TryBufferData () |> ignore
                      renderTexture.Bind ()
                  )            
                  
                  match p with
  