diff --git a/ccitt/gen.go b/ccitt/gen.go
index c4d4bc9..0245f66 100644
--- a/ccitt/gen.go
+++ b/ccitt/gen.go
@@ -26,12 +26,12 @@
 		w := &bytes.Buffer{}
 		w.WriteString(header)
 		w.WriteString(headerComment)
-		write(w, build(modeCodes[:], 0), "modeTable",
-			"// modeTable represents Table 1 and the End-of-Line code.\n")
-		write(w, build(whiteCodes[:], 0), "whiteTable",
-			"// whiteTable represents Tables 2 and 3 for a white run.\n")
-		write(w, build(blackCodes[:], 0), "blackTable",
-			"// blackTable represents Tables 2 and 3 for a black run.\n")
+		write(w, build(modeCodes[:], 0), "modeDecodeTable",
+			"// modeDecodeTable represents Table 1 and the End-of-Line code.\n")
+		write(w, build(whiteCodes[:], 0), "whiteDecodeTable",
+			"// whiteDecodeTable represents Tables 2 and 3 for a white run.\n")
+		write(w, build(blackCodes[:], 0), "blackDecodeTable",
+			"// blackDecodeTable represents Tables 2 and 3 for a black run.\n")
 		writeMaxCodeLength(w, modeCodes[:], whiteCodes[:], blackCodes[:])
 		finish(w, "table.go")
 	}
@@ -51,9 +51,9 @@
 `
 
 const headerComment = `
-// Each table is represented by an array of [2]int16's: a binary tree. Each
-// array element (other than element 0, which means invalid) is a branch node
-// in that tree. The root node is always element 1 (the second element).
+// Each decodeTable is represented by an array of [2]int16's: a binary tree.
+// Each array element (other than element 0, which means invalid) is a branch
+// node in that tree. The root node is always element 1 (the second element).
 //
 // To walk the tree, look at the next bit in the bit stream, using it to select
 // the first or second element of the [2]int16. If that int16 is 0, we have an
@@ -61,16 +61,16 @@
 // then we have a leaf node, whose value is the bitwise complement (the ^
 // operator) of that int16.
 //
-// Comments above each table also show the same structure visually. The "b123"
-// lines show the 123'rd branch node. The "=XXXXX" lines show an invalid code.
-// The "=v1234" lines show a leaf node with value 1234. When reading the bit
-// stream, a 0 or 1 bit means to go up or down, as you move left to right.
+// Comments above each decodeTable also show the same structure visually. The
+// "b123" lines show the 123'rd branch node. The "=XXXXX" lines show an invalid
+// code. The "=v1234" lines show a leaf node with value 1234. When reading the
+// bit stream, a 0 or 1 bit means to go up or down, as you move left to right.
 //
-// For example, in modeTable, branch node b005 is three steps up from the root
-// node, meaning that we have already seen "000". If the next bit is "0" then
-// we move to branch node b006. Otherwise, the next bit is "1", and we move to
-// the leaf node v0000 (also known as the modePass constant). Indeed, the bits
-// that encode modePass are "0001".
+// For example, in modeDecodeTable, branch node b005 is three steps up from the
+// root node, meaning that we have already seen "000". If the next bit is "0"
+// then we move to branch node b006. Otherwise, the next bit is "1", and we
+// move to the leaf node v0000 (also known as the modePass constant). Indeed,
+// the bits that encode modePass are "0001".
 //
 // Tables 1, 2 and 3 come from the "ITU-T Recommendation T.6: FACSIMILE CODING
 // SCHEMES AND CODING CONTROL FUNCTIONS FOR GROUP 4 FACSIMILE APPARATUS"
diff --git a/ccitt/reader.go b/ccitt/reader.go
index bd856a1..ef353dc 100644
--- a/ccitt/reader.go
+++ b/ccitt/reader.go
@@ -107,7 +107,7 @@
 	}
 }
 
-func decode(b *bitReader, table [][2]int16) (uint32, error) {
+func decode(b *bitReader, decodeTable [][2]int16) (uint32, error) {
 	nBitsRead, bitsRead, state := uint32(0), uint32(0), int32(1)
 	for {
 		bit, err := b.nextBit()
@@ -117,7 +117,7 @@
 		bitsRead |= bit << nBitsRead
 		nBitsRead++
 		// The "&1" is redundant, but can eliminate a bounds check.
-		state = int32(table[state][bit&1])
+		state = int32(decodeTable[state][bit&1])
 		if state < 0 {
 			return uint32(^state), nil
 		} else if state == 0 {
diff --git a/ccitt/reader_test.go b/ccitt/reader_test.go
index 8564d28..a1b9451 100644
--- a/ccitt/reader_test.go
+++ b/ccitt/reader_test.go
@@ -37,7 +37,7 @@
 	}
 }
 
-func testTable(t *testing.T, table [][2]int16, codes []code, values []uint32) {
+func testDecodeTable(t *testing.T, decodeTable [][2]int16, codes []code, values []uint32) {
 	// Build a map from values to codes.
 	m := map[uint32]string{}
 	for _, code := range codes {
@@ -74,7 +74,7 @@
 	}
 	finalValue := values[len(values)-1]
 	for {
-		v, err := decode(r, table)
+		v, err := decode(r, decodeTable)
 		if err != nil {
 			t.Fatalf("after got=%d: %v", got, err)
 		}
@@ -90,8 +90,8 @@
 	}
 }
 
-func TestModeTable(t *testing.T) {
-	testTable(t, modeTable[:], modeCodes, []uint32{
+func TestModeDecodeTable(t *testing.T) {
+	testDecodeTable(t, modeDecodeTable[:], modeCodes, []uint32{
 		modePass,
 		modeV0,
 		modeV0,
@@ -107,42 +107,42 @@
 	})
 }
 
-func TestWhiteTable(t *testing.T) {
-	testTable(t, whiteTable[:], whiteCodes, []uint32{
+func TestWhiteDecodeTable(t *testing.T) {
+	testDecodeTable(t, whiteDecodeTable[:], whiteCodes, []uint32{
 		0, 1, 256, 7, 128, 3, 2560,
 	})
 }
 
-func TestBlackTable(t *testing.T) {
-	testTable(t, blackTable[:], blackCodes, []uint32{
+func TestBlackDecodeTable(t *testing.T) {
+	testDecodeTable(t, blackDecodeTable[:], blackCodes, []uint32{
 		63, 64, 63, 64, 64, 63, 22, 1088, 2048, 7, 6, 5, 4, 3, 2, 1, 0,
 	})
 }
 
-func TestInvalidCode(t *testing.T) {
+func TestDecodeInvalidCode(t *testing.T) {
 	// The bit stream is:
 	// 1 010 000000011011
 	// Packing that LSB-first gives:
 	// 0b_1101_1000_0000_0101
 	src := []byte{0x05, 0xD8}
 
-	table := modeTable[:]
+	decodeTable := modeDecodeTable[:]
 	r := &bitReader{
 		r: bytes.NewReader(src),
 	}
 
 	// "1" decodes to the value 2.
-	if v, err := decode(r, table); v != 2 || err != nil {
+	if v, err := decode(r, decodeTable); v != 2 || err != nil {
 		t.Fatalf("decode #0: got (%v, %v), want (2, nil)", v, err)
 	}
 
 	// "010" decodes to the value 6.
-	if v, err := decode(r, table); v != 6 || err != nil {
+	if v, err := decode(r, decodeTable); v != 6 || err != nil {
 		t.Fatalf("decode #0: got (%v, %v), want (6, nil)", v, err)
 	}
 
 	// "00000001" is an invalid code.
-	if v, err := decode(r, table); v != 0 || err != errInvalidCode {
+	if v, err := decode(r, decodeTable); v != 0 || err != errInvalidCode {
 		t.Fatalf("decode #0: got (%v, %v), want (0, %v)", v, err, errInvalidCode)
 	}
 
diff --git a/ccitt/table.go b/ccitt/table.go
index 6a8cfe1..29d0ea4 100644
--- a/ccitt/table.go
+++ b/ccitt/table.go
@@ -2,9 +2,9 @@
 
 package ccitt
 
-// Each table is represented by an array of [2]int16's: a binary tree. Each
-// array element (other than element 0, which means invalid) is a branch node
-// in that tree. The root node is always element 1 (the second element).
+// Each decodeTable is represented by an array of [2]int16's: a binary tree.
+// Each array element (other than element 0, which means invalid) is a branch
+// node in that tree. The root node is always element 1 (the second element).
 //
 // To walk the tree, look at the next bit in the bit stream, using it to select
 // the first or second element of the [2]int16. If that int16 is 0, we have an
@@ -12,16 +12,16 @@
 // then we have a leaf node, whose value is the bitwise complement (the ^
 // operator) of that int16.
 //
-// Comments above each table also show the same structure visually. The "b123"
-// lines show the 123'rd branch node. The "=XXXXX" lines show an invalid code.
-// The "=v1234" lines show a leaf node with value 1234. When reading the bit
-// stream, a 0 or 1 bit means to go up or down, as you move left to right.
+// Comments above each decodeTable also show the same structure visually. The
+// "b123" lines show the 123'rd branch node. The "=XXXXX" lines show an invalid
+// code. The "=v1234" lines show a leaf node with value 1234. When reading the
+// bit stream, a 0 or 1 bit means to go up or down, as you move left to right.
 //
-// For example, in modeTable, branch node b005 is three steps up from the root
-// node, meaning that we have already seen "000". If the next bit is "0" then
-// we move to branch node b006. Otherwise, the next bit is "1", and we move to
-// the leaf node v0000 (also known as the modePass constant). Indeed, the bits
-// that encode modePass are "0001".
+// For example, in modeDecodeTable, branch node b005 is three steps up from the
+// root node, meaning that we have already seen "000". If the next bit is "0"
+// then we move to branch node b006. Otherwise, the next bit is "1", and we
+// move to the leaf node v0000 (also known as the modePass constant). Indeed,
+// the bits that encode modePass are "0001".
 //
 // Tables 1, 2 and 3 come from the "ITU-T Recommendation T.6: FACSIMILE CODING
 // SCHEMES AND CODING CONTROL FUNCTIONS FOR GROUP 4 FACSIMILE APPARATUS"
@@ -29,7 +29,7 @@
 //
 // https://www.itu.int/rec/dologin_pub.asp?lang=e&id=T-REC-T.6-198811-I!!PDF-E&type=items
 
-// modeTable represents Table 1 and the End-of-Line code.
+// modeDecodeTable represents Table 1 and the End-of-Line code.
 //
 //                              +=XXXXX
 // b015                       +-+
@@ -62,7 +62,7 @@
 //        |   +=v0003
 // b001 +-+
 //        +=v0002
-var modeTable = [...][2]int16{
+var modeDecodeTable = [...][2]int16{
 	0:  {0, 0},
 	1:  {2, ^2},
 	2:  {3, 4},
@@ -81,7 +81,7 @@
 	15: {0, ^10},
 }
 
-// whiteTable represents Tables 2 and 3 for a white run.
+// whiteDecodeTable represents Tables 2 and 3 for a white run.
 //
 //                      +=XXXXX
 // b059               +-+
@@ -292,7 +292,7 @@
 //            | +=v0006
 // b015       +-+
 //              +=v0007
-var whiteTable = [...][2]int16{
+var whiteDecodeTable = [...][2]int16{
 	0:   {0, 0},
 	1:   {2, 3},
 	2:   {4, 5},
@@ -400,7 +400,7 @@
 	104: {^2496, ^2560},
 }
 
-// blackTable represents Tables 2 and 3 for a black run.
+// blackDecodeTable represents Tables 2 and 3 for a black run.
 //
 //                      +=XXXXX
 // b017               +-+
@@ -611,7 +611,7 @@
 //        | +=v0003
 // b003   +-+
 //          +=v0002
-var blackTable = [...][2]int16{
+var blackDecodeTable = [...][2]int16{
 	0:   {0, 0},
 	1:   {2, 3},
 	2:   {4, 5},