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: 
                  if llid = 0 then
                      let v = if lid >= 64 then lv - data.[lid - 4*64] else lv
                      let lSize, lc = encode llid (llz % 16) v
                      lCode <- lc
                      lLength <- lSize
  
                  elif lnz then
                      let lSize, lc = encode llid (llz % 16) lv
                      lCode <- lc
                      lLength <- lSize
  
  
negative.code:             [<GLSLIntrinsic("atomicOr({0}, {1})")>]
              static member AtomicOr(r : 'a, v : 'a) : unit =
                  failwith ""
              [<GLSLIntrinsic("atomicAdd({0}, {1})")>]
              static member AtomicAdd(r : 'a, v : 'a) : 'a =
                  failwith ""
  
  
          let dcLumInv = Jpeg.Huffman.photoshop.dcLumInv |> Array.map (fun c -> (uint32 c.Length) ||| (uint32 c.Store <<< 16))
          let dcChromaInv = Jpeg.Huffman.photoshop.dcChromaInv |> Array.map (fun c -> (uint32 c.Length) ||| (uint32 c.Store <<< 16))
          let acLumInv = Jpeg.Huffman.photoshop.acLumInv |> Array.map (fun c -> (uint32 c.Length) ||| (uint32 c.Store <<< 16))
          let acChromaInv = Jpeg.Huffman.photoshop.acChromaInv |> Array.map (fun c -> (uint32 c.Length) ||| (uint32 c.Store <<< 16))
  
          let lenMask = 0x000000FFu
          let huffMask = 0xFFFF0000u
  
          let encode (index : int) (chroma : bool) (leading : int) (value : float) : int * uint32 =
              let value = int value
              if chroma then
                  if index = 0 then
                      let dc = Ballot.MSB(uint32 (abs value)) + 1
                      let off = if value < 0 then (1 <<< dc) else 0
                      let v = uint32 (off + value)
                      let huff = dcChromaInv.[dc]
                      let len = huff &&& lenMask |> int
                      let huff = huff &&& huffMask
  
                      len + dc, huff ||| (v <<< (32 - len + dc))
                  else
                      let dc = Ballot.MSB(uint32 (abs value)) + 1
                      let off = if value < 0 then (1 <<< dc) else 0
                      let v = uint32 (off + value)
                      let huff = acChromaInv.[dc]
                      let len = huff &&& lenMask |> int
                      let huff = huff &&& huffMask
  
                      len + dc, huff ||| (v <<< (32 - len + dc))
  
              else
                  if index = 0 then
                      let dc = Ballot.MSB(uint32 (abs value)) + 1
                      let off = if value < 0 then (1 <<< dc) else 0
                      let v = uint32 (off + value)
                      let huff = dcLumInv.[dc]
                      let len = huff &&& lenMask |> int
                      let huff = huff &&& huffMask
  
                      len + dc, huff ||| (v <<< (32 - len + dc))
                  else
                      let dc = Ballot.MSB(uint32 (abs value)) + 1
                      let off = if value < 0 then (1 <<< dc) else 0
                      let v = uint32 (off + value)
                      let huff = acLumInv.[dc]
                      let len = huff &&& lenMask |> int
                      let huff = huff &&& huffMask
  
                      len + dc, huff ||| (v <<< (32 - len + dc))
  
          let takeHigh (cnt : int) (word : uint32) =
              word >>> (32 - cnt)
  