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:     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
          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 = dcChrom.[dc]
                  let len = Codeword.length huff
                  let huff = Codeword.code huff
                  len + dc, (huff <<< dc) ||| v
              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 = acChrom.[dc]
                  let len = Codeword.length huff
                  let huff = Codeword.code huff
                  len + dc, (huff <<< dc) ||| v
  
          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 = dcLum.[dc]
                  let len = Codeword.length huff
                  let huff = Codeword.code huff
                  len + dc, (huff <<< dc) ||| v
              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 = acLum.[dc]
                  let len = Codeword.length huff
                  let huff = Codeword.code huff
                  len + dc, (huff <<< dc) ||| v
  
      [<LocalSize(X = 32)>]
      let encodeKernel (channel : int) (counter : int[]) (data : float[]) (ranges : V2i[]) (mask : uint32[]) =
  
negative.code:     let printMat8 (arr : 'a[]) =
          arr |> Array.map (sprintf "%A") |> Array.chunkBySize 8 |> Array.map (String.concat " ") |> Array.iter (Log.line "%s")
          
      let printBits (data : byte[]) =
          let mutable str = ""
          for i in 0 .. data.Length - 1 do
              let v = data.[i]
              let mutable mask = 1uy <<< 7
              for _ in 1 .. 8 do
                  if v &&& mask <> 0uy then str <- str + "1"
                  else str <- str + "0"
                  mask <- mask >>> 1
              str <- str + " "
          Log.line "%s" str
  
      let run() =
          use app = new HeadlessVulkanApplication(false)
          let device = app.Device
  