},
}

func TestUnscaledQuant(t *testing.T) {
	bad := false
	for i := quantIndex(0); i < nQuantIndex; i++ {
		for zig := 0; zig < blockSize; zig++ {
			got := unscaledQuant[i][zig]
			want := unscaledQuantInNaturalOrder[i][unzig[zig]]
			if got != want {
				t.Errorf("i=%d, zig=%d: got %d, want %d", i, zig, got, want)
				bad = true
			}
		}
	}
	if bad {
		names := [nQuantIndex]string{"Luminance", "Chrominance"}

//   least significant bits
// - the most significant bit (msb) in each output byte indicates if there
//   is a continuation byte (msb = 1)
// - signed integers are mapped to unsigned integers using "zig-zag"
//   encoding: Positive values x are written as 2*x + 0, negative values
//   are written as 2*(^x) + 1; that is, negative numbers are complemented
//   and whether to complement is encoded in bit 0.
//
// Design note:

000002a0  a8 31 00 8a 30 81 87 02  42 01 21 7e c2 26 cb 5e  |.1..0...B.!~.&.^|
000002b0  f1 2a d2 9b 7f 3f b4 d4  28 5e 63 5a 20 aa 28 87  |.*...?..(^cZ .(.|
000002c0  bb dd 5c 6a 91 a2 2d 03  7a 69 67 8b ca 84 a6 1f  |..\j..-.zig.....|
000002d0  d3 58 40 eb 5c 54 95 96  05 d0 37 63 e4 a6 1b 51  |.X@.\T....7c...Q|
000002e0  9a d0 93 31 82 e6 8e a0  af 29 64 02 41 4c ff ac  |...1.....)d.AL..|

func (w *Encoder) rawUvarint(x uint64) {
	var buf [binary.MaxVarintLen64]byte
	n := binary.PutUvarint(buf[:], x)
	_, err := w.Data.Write(buf[:n])
	w.checkErr(err)
}

func (w *Encoder) rawVarint(x int64) {
	// Zig-zag encode.
	ux := uint64(x) << 1
	if x < 0 {
		ux = ^ux
	}

	w.rawUvarint(ux)
}

func (w *Encoder) rawReloc(r RelocKind, idx Index) int {
	e := RelocEnt{r, idx}
	if w.RelocMap != nil {