anchor.diff:              word <<< cnt
   
           [<LocalSize(X = 32)>]
  -        let compact (channel : int) (data : float[]) (counts : int[]) (mask : uint32[]) =
  +        let compact (channel : int) (counter : int[]) (data : float[]) (ranges : V2i[]) (mask : uint32[]) =
               compute {
                   let mem = allocateShared 64
                   let temp = allocateShared 64
  +                let offsetStore = allocateShared 1
   
                   let offset = getWorkGroupId().X * 64
   
  
positive.code:             [<GLSLIntrinsic("atomicOr({0}, {1})")>]
              static member AtomicOr(r : 'a, v : 'a) : unit =
                  failwith ""
  
          let encode (index : int) (leading : int) (value : float) : int * uint32 =
              if index = 0 then
                  16, 0xDEAD0000u
              else
                  //let value = (uint32 leading <<< 16) ||| (uint32 (32768.0 + value))
                  8, 0xAB000000u
  
          let takeHigh (cnt : int) (word : uint32) =
              word >>> (32 - cnt)
  
negative.code: 
                  barrier()
  
                  let bitCnt = mem.[63]
                  let intCnt = (if bitCnt % 32 = 0 then bitCnt / 32 else 1 + bitCnt / 32)
                  if lid = 0 then
                      let off = Ballot.AtomicAdd(counter.[0], intCnt)
                      ranges.[getWorkGroupId().X] <- V2i(off, bitCnt)
                      offsetStore.[0] <- off
  
                  barrier()
                  let offset = offsetStore.[0]
  
                  if llid < intCnt then
                      mask.[offset + llid] <- temp.[llid]
                      
                  if rlid < intCnt then
                      mask.[offset + rlid] <- temp.[rlid]
  
              
              }
  