anchor.diff:                  let v = uint16 (off + v)
   
                   let index = (byte leadingZeros <<< 4) ||| byte dc
  -                let huff = Huffman.acChromInv.[int index]
  +                let huff = coder.acChromaInv.[int index]
                   x.Write huff
                   x.Write(Codeword(byte dc, v))
   
           let writeBlock (bs : BitStream) (block : V3i[]) =
  -
   
               bs.WriteDCLum(block.[0].X)
               let mutable leading = 0
  
positive.code:                     write [| l |]
                      current <- Codeword(0uy, 0us)
  
              member x.WriteDCLum(v : int) =
                  let dc = Fun.HighestBit(abs v) + 1
                  let off = if v < 0 then (1 <<< dc) - 1 else 0
                  let v = uint16 (off + v)
                  let huff = Huffman.dcLumInv.[dc]
                  x.Write(huff)
                  x.Write(Codeword(byte dc, v))
  
  
negative.code:             ms.Write(sof, 0, sof.Length)
  
              let huff =
                  let huffSize (spec : TableSpec)  =
                       uint16 (1 + 16 + spec.values.Length)
  
                  let encodeHuff (kind : byte) (spec : TableSpec) =
                      Array.concat [
                          [| kind |]
                          Array.skip 1 spec.counts |> Array.map byte
  