anchor.diff:                      if ci = 0 then Kernels.encoder.acLuminance.table.[0]
                       else Kernels.encoder.acChroma.table.[0]
   
  -                bs.Write(eob)
  +                bs.WriteCode(eob)
   
           bs.ToArray()
   
  
positive.code:         transform data alignedSize quality dctBuffer
  
          encode dctBuffer alignedSize
  
      member x.Transform(data : PixImage<'a>, quality : Quantization) =
          //assert(data.Size.X % 8 = 0 && data.Size.Y % 8 = 0)
  
negative.code:     let dcChrom = encoder.dcChroma.table
      let acChrom = encoder.acChroma.table
  
  
      let encode (index : int) (chroma : bool) (leading : int) (value : float) : int * uint32 =
          let value = int value
          
          let dc = Ballot.MSB(uint32 (abs value)) + 1
          let off = if value < 0 then (1 <<< dc) else 0
          let v = uint32 (off + value)
  
          let mutable key = dc
          if index <> 0 then
              key <- (leading <<< 4) ||| dc
  
          let mutable huff = 0u
          if index = 0 && chroma then huff <- dcChrom.[key]
          elif index = 0 then huff <- dcLum.[key]
          elif chroma then huff <- acChrom.[key]
          else huff <- acLum.[key]
              
          let len = Codeword.length huff
          let huff = Codeword.code huff
          len + dc, (huff <<< dc) ||| (v &&& ((1u <<< dc) - 1u))
         
  
      [<LocalSize(X = 32)>]
      let encodeKernel (channel : int) (counter : int[]) (data : float[]) (ranges : V2i[]) (mask : uint32[]) =
  