anchor.diff:  
           let arr = Array.zeroCreate 64
           b.Download(arr)
  -        printfn "%A" arr.[0]
  +
  +        let arr2 = 
  +            arr |> Array.map (fun v ->
  +                let lz = (v >>> 16) &&& 0xFFFFu |> int
  +                let v = int (v &&& 0xFFFFu) - 32768
  +                (lz,v)
  +            )
  +
  +        let cnts = Array.zeroCreate 1
  +        counts.Download(cnts)
  +   
  +        printfn "%A (%A)" arr2.[0] cnts.[0]
   
   
           let shader = device |> ComputeShader.ofFunction JpegGPU.dct
  
positive.code:         type Ballot () =
              
              [<GLSLIntrinsic("gl_SubGroupSizeARB", "GL_ARB_shader_ballot", "GL_ARB_gpu_shader_int64")>]
              static member GetSubGroupSize() : uint32 =
                  failwith ""
  
              [<GLSLIntrinsic("ballotARB({0})", "GL_ARB_shader_ballot", "GL_ARB_gpu_shader_int64")>]
              static member Ballot(a : bool) : uint64 =
                  failwith ""
  
          [<LocalSize(X = 64)>]
          let compact (mask : int[]) =
              compute {
                  let id = getGlobalId().X
                  //let lid = getLocalId().X
                  let r = Ballot.GetSubGroupSize()
                  mask.[id] <- int r
  
  //
  //                let value = data.[id *  4 + channel]
  //                let isZero = false
  //                let lz = 0
  //
  //                if isZero then
  //                    if lz < 16 then
  //                        mask.[id] <- 0
  //                    else
  //                        emit.[id] <- 0xFA
  //                        mask.[id] <- 1
  //                else
  //                    let lz = 
  
  
                  // Option<LeadingZeros * Value>
  
  
                  ()
  
              
              }
  
negative.code:         let shader = device |> ComputeShader.ofFunction JpegGPU.compact
          let input = ComputeShader.newInputBinding shader app.Runtime.DescriptorPool
  
  
          let data = device.CreateBuffer<V4f>(Array.init 64 (fun i -> if i % 3 = 0 then V4f(i,i,i,i) else V4f.Zero))
          let counts = device.CreateBuffer<int>(1L)
          let b = device.CreateBuffer<uint32>(64L)
          input.["channel"] <- 0
          input.["data"] <- data
          input.["counts"] <- counts
          input.["mask"] <- b
          input.Flush()
          
  