diff --git a/currency/format.go b/currency/format.go
index 97ce2d9..1115263 100644
--- a/currency/format.go
+++ b/currency/format.go
@@ -9,9 +9,8 @@
 	"io"
 	"sort"
 
-	"golang.org/x/text/internal"
 	"golang.org/x/text/internal/format"
-	"golang.org/x/text/language"
+	"golang.org/x/text/internal/language/compact"
 )
 
 // Amount is an amount-currency unit pair.
@@ -59,9 +58,9 @@
 // Format implements fmt.Formatter. It accepts format.State for
 // language-specific rendering.
 func (v formattedValue) Format(s fmt.State, verb rune) {
-	var lang int
+	var lang compact.ID
 	if state, ok := s.(format.State); ok {
-		lang, _ = language.CompactIndex(state.Language())
+		lang, _ = compact.RegionalID(compact.Tag(state.Language()))
 	}
 
 	// Get the options. Use DefaultFormat if not present.
@@ -138,7 +137,7 @@
 	currency Unit
 	kind     Kind
 
-	symbol func(compactIndex int, c Unit) string
+	symbol func(compactIndex compact.ID, c Unit) string
 }
 
 func (o *options) format(amount interface{}) formattedValue {
@@ -177,9 +176,9 @@
 func formSymbol(x interface{}) formattedValue { return optSymbol.format(x) }
 func formNarrow(x interface{}) formattedValue { return optNarrow.format(x) }
 
-func lookupISO(x int, c Unit) string    { return c.String() }
-func lookupSymbol(x int, c Unit) string { return normalSymbol.lookup(x, c) }
-func lookupNarrow(x int, c Unit) string { return narrowSymbol.lookup(x, c) }
+func lookupISO(x compact.ID, c Unit) string    { return c.String() }
+func lookupSymbol(x compact.ID, c Unit) string { return normalSymbol.lookup(x, c) }
+func lookupNarrow(x compact.ID, c Unit) string { return narrowSymbol.lookup(x, c) }
 
 type symbolIndex struct {
 	index []uint16 // position corresponds with compact index of language.
@@ -191,7 +190,7 @@
 	narrowSymbol = symbolIndex{narrowLangIndex, narrowSymIndex}
 )
 
-func (x *symbolIndex) lookup(lang int, c Unit) string {
+func (x *symbolIndex) lookup(lang compact.ID, c Unit) string {
 	for {
 		index := x.data[x.index[lang]:x.index[lang+1]]
 		i := sort.Search(len(index), func(i int) bool {
@@ -209,7 +208,7 @@
 		if lang == 0 {
 			break
 		}
-		lang = int(internal.Parent[lang])
+		lang = lang.Parent()
 	}
 	return c.String()
 }
diff --git a/currency/gen.go b/currency/gen.go
index 0952d41..da7712f 100644
--- a/currency/gen.go
+++ b/currency/gen.go
@@ -18,7 +18,8 @@
 	"strings"
 	"time"
 
-	"golang.org/x/text/internal"
+	"golang.org/x/text/internal/language/compact"
+
 	"golang.org/x/text/internal/gen"
 	"golang.org/x/text/internal/tag"
 	"golang.org/x/text/language"
@@ -265,7 +266,7 @@
 		numTypes
 	)
 	// language -> currency -> type ->  symbol
-	var symbols [language.NumCompactTags][][numTypes]*string
+	var symbols [compact.NumCompactTags][][numTypes]*string
 
 	// Collect symbol information per language.
 	for _, lang := range data.Locales() {
@@ -274,7 +275,7 @@
 			continue
 		}
 
-		langIndex, ok := language.CompactIndex(language.MustParse(lang))
+		langIndex, ok := compact.LanguageID(compact.Tag(language.MustParse(lang)))
 		if !ok {
 			log.Fatalf("No compact index for language %s", lang)
 		}
@@ -318,8 +319,8 @@
 				if sym == nil {
 					continue
 				}
-				for p := uint16(langIndex); p != 0; {
-					p = internal.Parent[p]
+				for p := compact.ID(langIndex); p != 0; {
+					p = p.Parent()
 					x := symbols[p]
 					if x == nil {
 						continue
diff --git a/date/gen_test.go b/date/gen_test.go
index 798cb4f..b6b9159 100644
--- a/date/gen_test.go
+++ b/date/gen_test.go
@@ -11,6 +11,7 @@
 
 	"golang.org/x/text/internal/cldrtree"
 	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/internal/testtext"
 	"golang.org/x/text/language"
 	"golang.org/x/text/unicode/cldr"
@@ -36,7 +37,7 @@
 		if ldml.Dates == nil {
 			continue
 		}
-		tag, _ := language.CompactIndex(language.MustParse(lang))
+		tag, _ := compact.RegionalID(compact.Tag(language.MustParse(lang)))
 
 		test := func(want cldrtree.Element, path ...string) {
 			if count > 30 {
diff --git a/feature/plural/gen.go b/feature/plural/gen.go
index a0de986..104986a 100644
--- a/feature/plural/gen.go
+++ b/feature/plural/gen.go
@@ -63,9 +63,9 @@
 	"strconv"
 	"strings"
 
-	"golang.org/x/text/internal"
 	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/language"
+	"golang.org/x/text/internal/language"
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/unicode/cldr"
 )
 
@@ -198,7 +198,7 @@
 
 		rules := []pluralCheck{}
 		index := []byte{0}
-		langMap := map[int]byte{0: 0} // From compact language index to index
+		langMap := map[compact.ID]byte{0: 0}
 
 		for _, pRules := range plurals.PluralRules {
 			// Parse the rules.
@@ -251,7 +251,7 @@
 				if strings.TrimSpace(loc) == "" {
 					continue
 				}
-				lang, ok := language.CompactIndex(language.MustParse(loc))
+				lang, ok := compact.FromTag(language.MustParse(loc))
 				if !ok {
 					log.Printf("No compact index for locale %q", loc)
 				}
@@ -261,16 +261,28 @@
 		}
 		w.WriteVar(plurals.Type+"Rules", rules)
 		w.WriteVar(plurals.Type+"Index", index)
-		// Expand the values.
-		langToIndex := make([]byte, language.NumCompactTags)
+		// Expand the values: first by using the parent relationship.
+		langToIndex := make([]byte, compact.NumCompactTags)
 		for i := range langToIndex {
-			for p := i; ; p = int(internal.Parent[p]) {
+			for p := compact.ID(i); ; p = p.Parent() {
 				if x, ok := langMap[p]; ok {
 					langToIndex[i] = x
 					break
 				}
 			}
 		}
+		// Now expand by including entries with identical languages for which
+		// one isn't set.
+		for i, v := range langToIndex {
+			if v == 0 {
+				id, _ := compact.FromTag(language.Tag{
+					LangID: compact.ID(i).Tag().LangID,
+				})
+				if p := langToIndex[id]; p != 0 {
+					langToIndex[i] = p
+				}
+			}
+		}
 		w.WriteVar(plurals.Type+"LangToIndex", langToIndex)
 		// Need to convert array to slice because of golang.org/issue/7651.
 		// This will allow tables to be dropped when unused. This is especially
diff --git a/feature/plural/plural.go b/feature/plural/plural.go
index 61faf18..517a628 100644
--- a/feature/plural/plural.go
+++ b/feature/plural/plural.go
@@ -13,6 +13,7 @@
 package plural
 
 import (
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/internal/number"
 	"golang.org/x/text/language"
 )
@@ -113,7 +114,7 @@
 //      100000     []byte{1}           6      0
 //      100000.00  []byte{1}           6      3
 func (p *Rules) MatchDigits(t language.Tag, digits []byte, exp, scale int) Form {
-	index, _ := language.CompactIndex(t)
+	index := tagToID(t)
 
 	// Differentiate up to including mod 1000000 for the integer part.
 	n := getIntApprox(digits, 0, exp, 6, 1000000)
@@ -130,8 +131,7 @@
 }
 
 func validForms(p *Rules, t language.Tag) (forms []Form) {
-	index, _ := language.CompactIndex(t)
-	offset := p.langToIndex[index]
+	offset := p.langToIndex[tagToID(t)]
 	rules := p.rules[p.index[offset]:p.index[offset+1]]
 
 	forms = append(forms, Other)
@@ -146,8 +146,7 @@
 }
 
 func (p *Rules) matchComponents(t language.Tag, n, f, scale int) Form {
-	index, _ := language.CompactIndex(t)
-	return matchPlural(p, index, n, f, scale)
+	return matchPlural(p, tagToID(t), n, f, scale)
 }
 
 // MatchPlural returns the plural form for the given language and plural
@@ -165,11 +164,10 @@
 // If any of the operand values is too large to fit in an int, it is okay to
 // pass the value modulo 10,000,000.
 func (p *Rules) MatchPlural(lang language.Tag, i, v, w, f, t int) Form {
-	index, _ := language.CompactIndex(lang)
-	return matchPlural(p, index, i, f, v)
+	return matchPlural(p, tagToID(lang), i, f, v)
 }
 
-func matchPlural(p *Rules, index int, n, f, v int) Form {
+func matchPlural(p *Rules, index compact.ID, n, f, v int) Form {
 	nMask := p.inclusionMasks[n%maxMod]
 	// Compute the fMask inline in the rules below, as it is relatively rare.
 	// fMask := p.inclusionMasks[f%maxMod]
@@ -256,3 +254,8 @@
 	}
 	return Other
 }
+
+func tagToID(t language.Tag) compact.ID {
+	id, _ := compact.RegionalID(compact.Tag(t))
+	return id
+}
diff --git a/feature/plural/plural_test.go b/feature/plural/plural_test.go
index b3cf4c4..feee4f0 100644
--- a/feature/plural/plural_test.go
+++ b/feature/plural/plural_test.go
@@ -189,8 +189,8 @@
 
 func BenchmarkPluralSimpleCases(b *testing.B) {
 	p := Cardinal
-	en, _ := language.CompactIndex(language.English)
-	zh, _ := language.CompactIndex(language.Chinese)
+	en := tagToID(language.English)
+	zh := tagToID(language.Chinese)
 	for i := 0; i < b.N; i++ {
 		matchPlural(p, en, 0, 0, 0)  // 0
 		matchPlural(p, en, 1, 0, 0)  // 1
@@ -203,8 +203,8 @@
 
 func BenchmarkPluralComplexCases(b *testing.B) {
 	p := Cardinal
-	ar, _ := language.CompactIndex(language.Arabic)
-	lv, _ := language.CompactIndex(language.Latvian)
+	ar := tagToID(language.Arabic)
+	lv := tagToID(language.Latvian)
 	for i := 0; i < b.N; i++ {
 		matchPlural(p, lv, 0, 19, 2)    // 0.19
 		matchPlural(p, lv, 11, 0, 3)    // 11.000
diff --git a/feature/plural/tables.go b/feature/plural/tables.go
index 188820b..59ae9f2 100644
--- a/feature/plural/tables.go
+++ b/feature/plural/tables.go
@@ -85,8 +85,8 @@
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
-	0x00, 0x10, 0x10, 0x00, 0x00, 0x05, 0x05, 0x00,
+	0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10,
+	0x10, 0x10, 0x10, 0x00, 0x00, 0x05, 0x05, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	// Entry 40 - 7F
 	0x12, 0x12, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -149,7 +149,7 @@
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x0d, 0x0d, 0x02, 0x02, 0x02,
+	0x00, 0x00, 0x02, 0x0d, 0x0d, 0x02, 0x02, 0x02,
 	0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	// Entry 200 - 23F
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -177,7 +177,7 @@
 	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x07, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00,
 	// Entry 2C0 - 2FF
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00,
@@ -409,12 +409,12 @@
 	0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
 	0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
 	0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
-	0x01, 0x01, 0x08, 0x08, 0x04, 0x04, 0x08, 0x00,
-	0x00, 0x08, 0x08, 0x00, 0x00, 0x1a, 0x1a, 0x08,
+	0x01, 0x01, 0x08, 0x08, 0x04, 0x04, 0x08, 0x08,
+	0x08, 0x08, 0x08, 0x00, 0x00, 0x1a, 0x1a, 0x08,
 	0x08, 0x08, 0x08, 0x08, 0x08, 0x06, 0x00, 0x00,
 	// Entry 40 - 7F
 	0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x1e,
-	0x08, 0x08, 0x13, 0x00, 0x00, 0x13, 0x13, 0x04,
+	0x08, 0x08, 0x13, 0x13, 0x13, 0x13, 0x13, 0x04,
 	0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x08,
 	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
 	0x18, 0x18, 0x00, 0x00, 0x22, 0x22, 0x09, 0x09,
@@ -459,8 +459,8 @@
 	0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	// Entry 180 - 1BF
 	0x00, 0x04, 0x0a, 0x0a, 0x04, 0x04, 0x04, 0x04,
-	0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08,
-	0x00, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x02,
+	0x04, 0x10, 0x17, 0x00, 0x00, 0x00, 0x08, 0x08,
+	0x04, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x02,
 	0x02, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08,
 	0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01,
@@ -473,7 +473,7 @@
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x0d, 0x08,
 	0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06,
 	0x00, 0x00, 0x08, 0x08, 0x0b, 0x0b, 0x08, 0x08,
-	0x08, 0x08, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,
+	0x08, 0x08, 0x12, 0x01, 0x01, 0x00, 0x00, 0x00,
 	0x00, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00,
 	// Entry 200 - 23F
 	0x00, 0x08, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08,
@@ -481,8 +481,8 @@
 	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00,
 	0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x08,
 	0x06, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08,
-	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x06, 0x00,
-	0x00, 0x06, 0x06, 0x08, 0x19, 0x19, 0x0d, 0x0d,
+	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x08, 0x19, 0x19, 0x0d, 0x0d,
 	0x08, 0x08, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04,
 	// Entry 240 - 27F
 	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00,
@@ -491,7 +491,7 @@
 	0x1d, 0x1d, 0x1d, 0x00, 0x00, 0x08, 0x08, 0x00,
 	0x00, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x08,
 	0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x11, 0x11,
+	0x00, 0x00, 0x13, 0x11, 0x11, 0x11, 0x11, 0x11,
 	0x05, 0x05, 0x18, 0x18, 0x15, 0x15, 0x10, 0x10,
 	// Entry 280 - 2BF
 	0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08,
@@ -501,11 +501,11 @@
 	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x08,
 	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
 	0x08, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06,
-	0x08, 0x08, 0x08, 0x00, 0x08, 0x00, 0x00, 0x08,
+	0x08, 0x08, 0x08, 0x0c, 0x08, 0x00, 0x00, 0x08,
 	// Entry 2C0 - 2FF
 	0x08, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x07,
 	0x07, 0x08, 0x08, 0x1d, 0x1d, 0x04, 0x04, 0x04,
-	0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x00,
+	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08,
 	0x08, 0x08, 0x08, 0x06, 0x08, 0x08, 0x00, 0x00,
 	0x08, 0x08, 0x08, 0x00, 0x00, 0x04, 0x04, 0x00,
@@ -549,4 +549,4 @@
 
 // Slots used for cardinal: A6 of 0xFF rules; 24 of 0xFF indexes; 37 of 64 sets
 
-// Total table size 3860 bytes (3KiB); checksum: B96047F
+// Total table size 3860 bytes (3KiB); checksum: 4E56F7B1
diff --git a/gen.go b/gen.go
index 1060b2b..3131edd 100644
--- a/gen.go
+++ b/gen.go
@@ -109,8 +109,8 @@
 
 	var (
 		cldr       = generate("./unicode/cldr", unicode)
-		langint    = generate("./internal/language", cldr)
-		language   = generate("./language", cldr, langint)
+		compact    = generate("./internal/language/compact", cldr)
+		language   = generate("./language", cldr, compact)
 		internal   = generate("./internal", unicode, language)
 		norm       = generate("./unicode/norm", unicode)
 		rangetable = generate("./unicode/rangetable", unicode)
diff --git a/internal/cldrtree/cldrtree_test.go b/internal/cldrtree/cldrtree_test.go
index d93c763..15960c8 100644
--- a/internal/cldrtree/cldrtree_test.go
+++ b/internal/cldrtree/cldrtree_test.go
@@ -18,6 +18,7 @@
 	"testing"
 
 	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/language"
 	"golang.org/x/text/unicode/cldr"
 )
@@ -277,7 +278,7 @@
 
 	for _, tc := range testCases {
 		t.Run(tc.desc, func(t *testing.T) {
-			tag, _ := language.CompactIndex(language.MustParse(tc.locale))
+			tag, _ := compact.RegionalID(compact.Tag(language.MustParse(tc.locale)))
 			s := tc.tree.lookup(tag, tc.isFeature, tc.path...)
 			if s != tc.result {
 				t.Errorf("got %q; want %q", s, tc.result)
diff --git a/internal/cldrtree/tree.go b/internal/cldrtree/tree.go
index 6d4084b..9321947 100644
--- a/internal/cldrtree/tree.go
+++ b/internal/cldrtree/tree.go
@@ -5,7 +5,7 @@
 package cldrtree
 
 import (
-	"golang.org/x/text/internal"
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/language"
 )
 
@@ -30,17 +30,17 @@
 // Each subsequent element in path indicates which subtree to select data from.
 // The last element of the path must select a leaf node. All other elements
 // of the path select a subindex.
-func (t *Tree) Lookup(tag int, path ...uint16) string {
+func (t *Tree) Lookup(tag compact.ID, path ...uint16) string {
 	return t.lookup(tag, false, path...)
 }
 
 // LookupFeature is like Lookup, but will first check whether a value of "other"
 // as a fallback before traversing the inheritance chain.
-func (t *Tree) LookupFeature(tag int, path ...uint16) string {
+func (t *Tree) LookupFeature(tag compact.ID, path ...uint16) string {
 	return t.lookup(tag, true, path...)
 }
 
-func (t *Tree) lookup(tag int, isFeature bool, path ...uint16) string {
+func (t *Tree) lookup(tag compact.ID, isFeature bool, path ...uint16) string {
 	origLang := tag
 outer:
 	for {
@@ -86,7 +86,7 @@
 		if tag == 0 {
 			break
 		}
-		tag = int(internal.Parent[tag])
+		tag = tag.Parent()
 	}
 	return ""
 }
@@ -105,9 +105,9 @@
 	}
 	// Set locales for which we don't have data to the parent's data.
 	for i, v := range t.Locales {
-		p := uint16(i)
+		p := compact.ID(i)
 		for v == 0 && p != 0 {
-			p = internal.Parent[p]
+			p = p.Parent()
 			v = t.Locales[p]
 		}
 		t.Locales[i] = v
diff --git a/internal/export/idna/tables10.0.0.go b/internal/export/idna/tables10.0.0.go
index 8e46655..d8f5926 100644
--- a/internal/export/idna/tables10.0.0.go
+++ b/internal/export/idna/tables10.0.0.go
@@ -7,7 +7,7 @@
 // UnicodeVersion is the Unicode version from which the tables in this package are derived.
 const UnicodeVersion = "10.0.0"
 
-var mappings string = "" + // Size: 8176 bytes
+var mappings string = "" + // Size: 8175 bytes
 	"\x00\x01 \x03 ̈\x01a\x03 ̄\x012\x013\x03 ́\x03 ̧\x011\x01o\x051⁄4\x051⁄2" +
 	"\x053⁄4\x03i̇\x03l·\x03ʼn\x01s\x03dž\x03ⱥ\x03ⱦ\x01h\x01j\x01r\x01w\x01y" +
 	"\x03 ̆\x03 ̇\x03 ̊\x03 ̨\x03 ̃\x03 ̋\x01l\x01x\x04̈́\x03 ι\x01;\x05 ̈́" +
@@ -4556,4 +4556,4 @@
 	{value: 0x0040, lo: 0xb0, hi: 0xbf},
 }
 
-// Total table size 42115 bytes (41KiB); checksum: F4A1FA4E
+// Total table size 42114 bytes (41KiB); checksum: 355A58A4
diff --git a/internal/gen.go b/internal/gen.go
deleted file mode 100644
index 1d678af..0000000
--- a/internal/gen.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"log"
-
-	"golang.org/x/text/internal/gen"
-	"golang.org/x/text/language"
-	"golang.org/x/text/unicode/cldr"
-)
-
-func main() {
-	r := gen.OpenCLDRCoreZip()
-	defer r.Close()
-
-	d := &cldr.Decoder{}
-	data, err := d.DecodeZip(r)
-	if err != nil {
-		log.Fatalf("DecodeZip: %v", err)
-	}
-
-	w := gen.NewCodeWriter()
-	defer w.WriteGoFile("tables.go", "internal")
-
-	// Create parents table.
-	parents := make([]uint16, language.NumCompactTags)
-	for _, loc := range data.Locales() {
-		tag := language.MustParse(loc)
-		index, ok := language.CompactIndex(tag)
-		if !ok {
-			continue
-		}
-		parentIndex := 0 // und
-		for p := tag.Parent(); p != language.Und; p = p.Parent() {
-			if x, ok := language.CompactIndex(p); ok {
-				parentIndex = x
-				break
-			}
-		}
-		parents[index] = uint16(parentIndex)
-	}
-
-	w.WriteComment(`
-	Parent maps a compact index of a tag to the compact index of the parent of
-	this tag.`)
-	w.WriteVar("Parent", parents)
-}
diff --git a/internal/gen_test.go b/internal/gen_test.go
deleted file mode 100644
index a2e1981..0000000
--- a/internal/gen_test.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package internal
-
-import (
-	"testing"
-
-	"golang.org/x/text/language"
-)
-
-func TestParents(t *testing.T) {
-	testCases := []struct {
-		tag, parent string
-	}{
-		{"af", "und"},
-		{"en", "und"},
-		{"en-001", "en"},
-		{"en-AU", "en-001"},
-		{"en-US", "en"},
-		{"en-US-u-va-posix", "en-US"},
-		{"ca-ES-valencia", "ca-ES"},
-	}
-	for _, tc := range testCases {
-		tag, ok := language.CompactIndex(language.MustParse(tc.tag))
-		if !ok {
-			t.Fatalf("Could not get index of flag %s", tc.tag)
-		}
-		want, ok := language.CompactIndex(language.MustParse(tc.parent))
-		if !ok {
-			t.Fatalf("Could not get index of parent %s of tag %s", tc.parent, tc.tag)
-		}
-		if got := int(Parent[tag]); got != want {
-			t.Errorf("Parent[%s] = %d; want %d (%s)", tc.tag, got, want, tc.parent)
-		}
-	}
-}
diff --git a/internal/internal.go b/internal/internal.go
index eac8328..3cddbbd 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate go run gen.go
-
 // Package internal contains non-exported functionality that are used by
 // packages in the text repository.
 package internal // import "golang.org/x/text/internal"
diff --git a/internal/language/compact/gen_index.go b/internal/language/compact/gen_index.go
index 475ca39..136cefa 100644
--- a/internal/language/compact/gen_index.go
+++ b/internal/language/compact/gen_index.go
@@ -52,6 +52,11 @@
 		m[tag] = true
 		// }
 	}
+
+	// TODO: plural rules are also defined for the deprecated tags:
+	//    iw mo sh tl
+	// Consider removing these as compact tags.
+
 	// Include locales for plural rules, which uses a different structure.
 	for _, plurals := range b.supp.Plurals {
 		for _, rules := range plurals.PluralRules {
diff --git a/internal/number/common.go b/internal/number/common.go
index 052876e..a6e9c8e 100644
--- a/internal/number/common.go
+++ b/internal/number/common.go
@@ -2,7 +2,11 @@
 
 package number
 
-import "unicode/utf8"
+import (
+	"unicode/utf8"
+
+	"golang.org/x/text/internal/language/compact"
+)
 
 // A system identifies a CLDR numbering system.
 type system byte
@@ -45,7 +49,7 @@
 type symOffset uint16
 
 type altSymData struct {
-	compactTag uint16
+	compactTag compact.ID
 	symIndex   symOffset
 	system     system
 }
diff --git a/internal/number/format.go b/internal/number/format.go
index ce1a762..cd94c5d 100644
--- a/internal/number/format.go
+++ b/internal/number/format.go
@@ -39,8 +39,7 @@
 
 func (f *Formatter) init(t language.Tag, index []uint8) {
 	f.Info = InfoFromTag(t)
-	ci, _ := language.CompactIndex(t)
-	f.Pattern = formats[index[ci]]
+	f.Pattern = formats[index[tagToID(t)]]
 }
 
 // InitPattern initializes a Formatter for the given Pattern.
diff --git a/internal/number/gen.go b/internal/number/gen.go
index 48f180f..c836221 100644
--- a/internal/number/gen.go
+++ b/internal/number/gen.go
@@ -14,11 +14,11 @@
 	"strings"
 	"unicode/utf8"
 
-	"golang.org/x/text/internal"
 	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/language"
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/internal/number"
 	"golang.org/x/text/internal/stringset"
-	"golang.org/x/text/language"
 	"golang.org/x/text/unicode/cldr"
 )
 
@@ -151,19 +151,19 @@
 	type symbols [NumSymbolTypes]string
 
 	type key struct {
-		tag    int // from language.CompactIndex
+		tag    compact.ID
 		system system
 	}
 	symbolMap := map[key]*symbols{}
 
-	defaults := map[int]system{}
+	defaults := map[compact.ID]system{}
 
 	for _, lang := range data.Locales() {
 		ldml := data.RawLDML(lang)
 		if ldml.Numbers == nil {
 			continue
 		}
-		langIndex, ok := language.CompactIndex(language.MustParse(lang))
+		langIndex, ok := compact.FromTag(language.MustParse(lang))
 		if !ok {
 			log.Fatalf("No compact index for language %s", lang)
 		}
@@ -213,7 +213,7 @@
 		for t := SymDecimal; t < NumSymbolTypes; t++ {
 			p := k.tag
 			for syms[t] == "" {
-				p = int(internal.Parent[p])
+				p = p.Parent()
 				if pSyms, ok := symbolMap[key{p, k.system}]; ok && (*pSyms)[t] != "" {
 					syms[t] = (*pSyms)[t]
 					break
@@ -234,7 +234,7 @@
 
 	for ns := system(0); ns < nNumberSystems; ns++ {
 		for _, l := range data.Locales() {
-			langIndex, _ := language.CompactIndex(language.MustParse(l))
+			langIndex, _ := compact.FromTag(language.MustParse(l))
 			s := symbolMap[key{langIndex, ns}]
 			if s == nil {
 				continue
@@ -255,7 +255,7 @@
 
 	// resolveSymbolIndex gets the index from the closest matching locale,
 	// including the locale itself.
-	resolveSymbolIndex := func(langIndex int, ns system) symOffset {
+	resolveSymbolIndex := func(langIndex compact.ID, ns system) symOffset {
 		for {
 			if sym := symbolMap[key{langIndex, ns}]; sym != nil {
 				return symOffset(m[*sym])
@@ -263,22 +263,22 @@
 			if langIndex == 0 {
 				return 0 // und, latn
 			}
-			langIndex = int(internal.Parent[langIndex])
+			langIndex = langIndex.Parent()
 		}
 	}
 
 	// Create an index with the symbols for each locale for the latn numbering
 	// system. If this is not the default, or the only one, for a locale, we
 	// will overwrite the value later.
-	var langToDefaults [language.NumCompactTags]symOffset
+	var langToDefaults [compact.NumCompactTags]symOffset
 	for _, l := range data.Locales() {
-		langIndex, _ := language.CompactIndex(language.MustParse(l))
+		langIndex, _ := compact.FromTag(language.MustParse(l))
 		langToDefaults[langIndex] = resolveSymbolIndex(langIndex, 0)
 	}
 
 	// Delete redundant entries.
 	for _, l := range data.Locales() {
-		langIndex, _ := language.CompactIndex(language.MustParse(l))
+		langIndex, _ := compact.FromTag(language.MustParse(l))
 		def := defaults[langIndex]
 		syms := symbolMap[key{langIndex, def}]
 		if syms == nil {
@@ -298,7 +298,7 @@
 	// be referenced if a user specified an alternative numbering system.
 	var langToAlt []altSymData
 	for _, l := range data.Locales() {
-		langIndex, _ := language.CompactIndex(language.MustParse(l))
+		langIndex, _ := compact.FromTag(language.MustParse(l))
 		start := len(langToAlt)
 		if start >= hasNonLatnMask {
 			log.Fatalf("Number of alternative assignments >= %x", hasNonLatnMask)
@@ -306,7 +306,7 @@
 		// Create the entry for the default value.
 		def := defaults[langIndex]
 		langToAlt = append(langToAlt, altSymData{
-			compactTag: uint16(langIndex),
+			compactTag: langIndex,
 			system:     def,
 			symIndex:   resolveSymbolIndex(langIndex, def),
 		})
@@ -317,7 +317,7 @@
 			}
 			if sym := symbolMap[key{langIndex, ns}]; sym != nil {
 				langToAlt = append(langToAlt, altSymData{
-					compactTag: uint16(langIndex),
+					compactTag: langIndex,
 					system:     ns,
 					symIndex:   resolveSymbolIndex(langIndex, ns),
 				})
@@ -361,16 +361,16 @@
 
 	// TODO: It would be possible to eliminate two of these slices by having
 	// another indirection and store a reference to the combination of patterns.
-	decimal := make([]byte, language.NumCompactTags)
-	scientific := make([]byte, language.NumCompactTags)
-	percent := make([]byte, language.NumCompactTags)
+	decimal := make([]byte, compact.NumCompactTags)
+	scientific := make([]byte, compact.NumCompactTags)
+	percent := make([]byte, compact.NumCompactTags)
 
 	for _, lang := range data.Locales() {
 		ldml := data.RawLDML(lang)
 		if ldml.Numbers == nil {
 			continue
 		}
-		langIndex, ok := language.CompactIndex(language.MustParse(lang))
+		langIndex, ok := compact.FromTag(language.MustParse(lang))
 		if !ok {
 			log.Fatalf("No compact index for language %s", lang)
 		}
@@ -440,8 +440,8 @@
 	// indicates an unspecified value.
 	for _, data := range [][]byte{decimal, scientific, percent} {
 		for i := range data {
-			p := uint16(i)
-			for ; data[p] == 0; p = internal.Parent[p] {
+			p := compact.ID(i)
+			for ; data[p] == 0; p = p.Parent() {
 			}
 			data[i] = data[p]
 		}
diff --git a/internal/number/gen_common.go b/internal/number/gen_common.go
index f88b838..b1b41a7 100644
--- a/internal/number/gen_common.go
+++ b/internal/number/gen_common.go
@@ -6,7 +6,11 @@
 
 package main
 
-import "unicode/utf8"
+import (
+	"unicode/utf8"
+
+	"golang.org/x/text/internal/language/compact"
+)
 
 // A system identifies a CLDR numbering system.
 type system byte
@@ -49,7 +53,7 @@
 type symOffset uint16
 
 type altSymData struct {
-	compactTag uint16
+	compactTag compact.ID
 	symIndex   symOffset
 	system     system
 }
diff --git a/internal/number/number.go b/internal/number/number.go
index 70c0836..fffc176 100644
--- a/internal/number/number.go
+++ b/internal/number/number.go
@@ -10,7 +10,7 @@
 import (
 	"unicode/utf8"
 
-	"golang.org/x/text/internal"
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/language"
 )
 
@@ -23,7 +23,7 @@
 // InfoFromLangID returns a Info for the given compact language identifier and
 // numbering system identifier. If system is the empty string, the default
 // numbering system will be taken for that language.
-func InfoFromLangID(compactIndex int, numberSystem string) Info {
+func InfoFromLangID(compactIndex compact.ID, numberSystem string) Info {
 	p := langToDefaults[compactIndex]
 	// Lookup the entry for the language.
 	pSymIndex := symOffset(0) // Default: Latin, default symbols
@@ -51,11 +51,11 @@
 					break
 				}
 				// Move to the parent and retry.
-				langIndex = int(internal.Parent[langIndex])
+				langIndex = langIndex.Parent()
 			} else {
 				// The index points to a list of symbol data indexes.
 				for _, e := range langToAlt[p&^hasNonLatnMask:] {
-					if int(e.compactTag) != langIndex {
+					if e.compactTag != langIndex {
 						if langIndex == 0 {
 							// The CLDR root defines full symbol information for
 							// all numbering systems (even though mostly by
@@ -73,7 +73,7 @@
 							continue outerLoop
 						}
 						// Fall back to parent.
-						langIndex = int(internal.Parent[langIndex])
+						langIndex = langIndex.Parent()
 					} else if e.system == ns {
 						pSymIndex = e.symIndex
 						break outerLoop
@@ -100,8 +100,7 @@
 
 // InfoFromTag returns a Info for the given language tag.
 func InfoFromTag(t language.Tag) Info {
-	index, _ := language.CompactIndex(t)
-	return InfoFromLangID(index, t.TypeForKey("nu"))
+	return InfoFromLangID(tagToID(t), t.TypeForKey("nu"))
 }
 
 // IsDecimal reports if the numbering system can convert decimal to native
@@ -144,6 +143,10 @@
 }
 
 func formatForLang(t language.Tag, index []byte) *Pattern {
-	x, _ := language.CompactIndex(t)
-	return &formats[index[x]]
+	return &formats[index[tagToID(t)]]
+}
+
+func tagToID(t language.Tag) compact.ID {
+	id, _ := compact.RegionalID(compact.Tag(t))
+	return id
 }
diff --git a/internal/number/tables_test.go b/internal/number/tables_test.go
index 054e23d..f1e542a 100644
--- a/internal/number/tables_test.go
+++ b/internal/number/tables_test.go
@@ -11,8 +11,9 @@
 	"testing"
 
 	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/language"
+	"golang.org/x/text/internal/language/compact"
 	"golang.org/x/text/internal/testtext"
-	"golang.org/x/text/language"
 	"golang.org/x/text/unicode/cldr"
 )
 
@@ -74,7 +75,7 @@
 		if ldml.Numbers == nil {
 			continue
 		}
-		langIndex, ok := language.CompactIndex(language.MustParse(lang))
+		langIndex, ok := compact.FromTag(language.MustParse(lang))
 		if !ok {
 			t.Fatalf("No compact index for language %s", lang)
 		}
diff --git a/internal/tables.go b/internal/tables.go
deleted file mode 100644
index 12d9c95..0000000
--- a/internal/tables.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
-
-package internal
-
-// Parent maps a compact index of a tag to the compact index of the parent of
-// this tag.
-var Parent = []uint16{ // 775 elements
-	// Entry 0 - 3F
-	0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0004, 0x0000, 0x0006,
-	0x0000, 0x0008, 0x0000, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
-	0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
-	0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
-	0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0000,
-	0x0000, 0x0028, 0x0000, 0x002a, 0x0000, 0x002c, 0x0000, 0x0000,
-	0x002f, 0x002e, 0x002e, 0x0000, 0x0033, 0x0000, 0x0035, 0x0000,
-	0x0037, 0x0000, 0x0039, 0x0000, 0x003b, 0x0000, 0x0000, 0x003e,
-	// Entry 40 - 7F
-	0x0000, 0x0040, 0x0040, 0x0000, 0x0043, 0x0043, 0x0000, 0x0046,
-	0x0000, 0x0048, 0x0000, 0x0000, 0x004b, 0x004a, 0x004a, 0x0000,
-	0x004f, 0x004f, 0x004f, 0x004f, 0x0000, 0x0054, 0x0054, 0x0000,
-	0x0057, 0x0000, 0x0059, 0x0000, 0x005b, 0x0000, 0x005d, 0x005d,
-	0x0000, 0x0060, 0x0000, 0x0062, 0x0000, 0x0064, 0x0000, 0x0066,
-	0x0066, 0x0000, 0x0069, 0x0000, 0x006b, 0x006b, 0x006b, 0x006b,
-	0x006b, 0x006b, 0x006b, 0x0000, 0x0073, 0x0000, 0x0075, 0x0000,
-	0x0077, 0x0000, 0x0000, 0x007a, 0x0000, 0x007c, 0x0000, 0x007e,
-	// Entry 80 - BF
-	0x0000, 0x0080, 0x0080, 0x0000, 0x0083, 0x0083, 0x0000, 0x0086,
-	0x0087, 0x0087, 0x0087, 0x0086, 0x0088, 0x0087, 0x0087, 0x0087,
-	0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0088,
-	0x0087, 0x0087, 0x0087, 0x0087, 0x0088, 0x0087, 0x0088, 0x0087,
-	0x0087, 0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
-	0x0087, 0x0087, 0x0087, 0x0086, 0x0087, 0x0087, 0x0087, 0x0087,
-	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
-	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0086, 0x0087, 0x0086,
-	// Entry C0 - FF
-	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
-	0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
-	0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0088, 0x0087,
-	0x0087, 0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
-	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0086, 0x0086, 0x0087,
-	0x0087, 0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0000,
-	0x00ef, 0x0000, 0x00f1, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2,
-	0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f1, 0x00f2, 0x00f1, 0x00f1,
-	// Entry 100 - 13F
-	0x00f2, 0x00f2, 0x00f1, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f1,
-	0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x0000, 0x010e,
-	0x0000, 0x0110, 0x0000, 0x0112, 0x0000, 0x0114, 0x0114, 0x0000,
-	0x0117, 0x0117, 0x0117, 0x0117, 0x0000, 0x011c, 0x0000, 0x011e,
-	0x0000, 0x0120, 0x0120, 0x0000, 0x0123, 0x0123, 0x0123, 0x0123,
-	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
-	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
-	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
-	// Entry 140 - 17F
-	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
-	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
-	0x0123, 0x0123, 0x0000, 0x0152, 0x0000, 0x0154, 0x0000, 0x0156,
-	0x0000, 0x0158, 0x0000, 0x015a, 0x0000, 0x015c, 0x015c, 0x015c,
-	0x0000, 0x0160, 0x0000, 0x0000, 0x0163, 0x0000, 0x0165, 0x0000,
-	0x0167, 0x0167, 0x0167, 0x0000, 0x016b, 0x0000, 0x016d, 0x0000,
-	0x016f, 0x0000, 0x0171, 0x0171, 0x0000, 0x0174, 0x0000, 0x0176,
-	0x0000, 0x0178, 0x0000, 0x017a, 0x0000, 0x017c, 0x0000, 0x017e,
-	// Entry 180 - 1BF
-	0x0000, 0x0000, 0x0000, 0x0182, 0x0000, 0x0184, 0x0184, 0x0184,
-	0x0184, 0x0000, 0x0000, 0x0000, 0x018b, 0x0000, 0x0000, 0x018e,
-	0x0000, 0x0000, 0x0191, 0x0000, 0x0000, 0x0000, 0x0195, 0x0000,
-	0x0197, 0x0000, 0x0000, 0x019a, 0x0000, 0x0000, 0x019d, 0x0000,
-	0x019f, 0x0000, 0x01a1, 0x0000, 0x01a3, 0x0000, 0x01a5, 0x0000,
-	0x01a7, 0x0000, 0x01a9, 0x0000, 0x01ab, 0x0000, 0x01ad, 0x0000,
-	0x01af, 0x0000, 0x01b1, 0x01b1, 0x0000, 0x01b4, 0x0000, 0x01b6,
-	0x0000, 0x01b8, 0x0000, 0x01ba, 0x0000, 0x01bc, 0x0000, 0x0000,
-	// Entry 1C0 - 1FF
-	0x01bf, 0x0000, 0x01c1, 0x0000, 0x01c3, 0x0000, 0x01c5, 0x0000,
-	0x01c7, 0x0000, 0x01c9, 0x0000, 0x01cb, 0x01cb, 0x01cb, 0x01cb,
-	0x0000, 0x01d0, 0x0000, 0x01d2, 0x01d2, 0x0000, 0x01d5, 0x0000,
-	0x01d7, 0x0000, 0x01d9, 0x0000, 0x01db, 0x0000, 0x01dd, 0x0000,
-	0x01df, 0x01df, 0x0000, 0x01e2, 0x0000, 0x01e4, 0x0000, 0x01e6,
-	0x0000, 0x01e8, 0x0000, 0x01ea, 0x0000, 0x01ec, 0x0000, 0x01ee,
-	0x0000, 0x01f0, 0x0000, 0x0000, 0x01f3, 0x0000, 0x01f5, 0x01f5,
-	0x01f5, 0x0000, 0x01f9, 0x0000, 0x01fb, 0x0000, 0x01fd, 0x0000,
-	// Entry 200 - 23F
-	0x01ff, 0x0000, 0x0000, 0x0202, 0x0000, 0x0204, 0x0204, 0x0000,
-	0x0207, 0x0000, 0x0209, 0x0209, 0x0000, 0x020c, 0x020c, 0x0000,
-	0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x0000,
-	0x0217, 0x0000, 0x0219, 0x0000, 0x021b, 0x0000, 0x0000, 0x0000,
-	0x0000, 0x0000, 0x0221, 0x0000, 0x0000, 0x0224, 0x0000, 0x0226,
-	0x0226, 0x0000, 0x0229, 0x0000, 0x022b, 0x022b, 0x0000, 0x0000,
-	0x022f, 0x022e, 0x022e, 0x0000, 0x0000, 0x0234, 0x0000, 0x0236,
-	0x0000, 0x0238, 0x0000, 0x0244, 0x023a, 0x0244, 0x0244, 0x0244,
-	// Entry 240 - 27F
-	0x0244, 0x0244, 0x0244, 0x0244, 0x023a, 0x0244, 0x0244, 0x0000,
-	0x0247, 0x0247, 0x0247, 0x0000, 0x024b, 0x0000, 0x024d, 0x0000,
-	0x024f, 0x024f, 0x0000, 0x0252, 0x0000, 0x0254, 0x0254, 0x0254,
-	0x0254, 0x0254, 0x0254, 0x0000, 0x025b, 0x0000, 0x025d, 0x0000,
-	0x025f, 0x0000, 0x0261, 0x0000, 0x0263, 0x0000, 0x0265, 0x0000,
-	0x0000, 0x0268, 0x0268, 0x0268, 0x0000, 0x026c, 0x0000, 0x026e,
-	0x0000, 0x0270, 0x0000, 0x0000, 0x0000, 0x0274, 0x0273, 0x0273,
-	0x0000, 0x0278, 0x0000, 0x027a, 0x0000, 0x027c, 0x0000, 0x0000,
-	// Entry 280 - 2BF
-	0x0000, 0x0000, 0x0281, 0x0000, 0x0000, 0x0284, 0x0000, 0x0286,
-	0x0286, 0x0286, 0x0286, 0x0000, 0x028b, 0x028b, 0x028b, 0x0000,
-	0x028f, 0x028f, 0x028f, 0x028f, 0x028f, 0x0000, 0x0295, 0x0295,
-	0x0295, 0x0295, 0x0000, 0x0000, 0x0000, 0x0000, 0x029d, 0x029d,
-	0x029d, 0x0000, 0x02a1, 0x02a1, 0x02a1, 0x02a1, 0x0000, 0x0000,
-	0x02a7, 0x02a7, 0x02a7, 0x02a7, 0x0000, 0x02ac, 0x0000, 0x02ae,
-	0x02ae, 0x0000, 0x02b1, 0x0000, 0x02b3, 0x0000, 0x02b5, 0x02b5,
-	0x0000, 0x0000, 0x02b9, 0x0000, 0x0000, 0x0000, 0x02bd, 0x0000,
-	// Entry 2C0 - 2FF
-	0x02bf, 0x02bf, 0x0000, 0x0000, 0x02c3, 0x0000, 0x02c5, 0x0000,
-	0x02c7, 0x0000, 0x02c9, 0x0000, 0x02cb, 0x0000, 0x02cd, 0x02cd,
-	0x0000, 0x0000, 0x02d1, 0x0000, 0x02d3, 0x02d0, 0x02d0, 0x0000,
-	0x0000, 0x02d8, 0x02d7, 0x02d7, 0x0000, 0x0000, 0x02dd, 0x0000,
-	0x02df, 0x0000, 0x02e1, 0x0000, 0x0000, 0x02e4, 0x0000, 0x02e6,
-	0x0000, 0x0000, 0x02e9, 0x0000, 0x02eb, 0x0000, 0x02ed, 0x0000,
-	0x02ef, 0x02ef, 0x0000, 0x0000, 0x02f3, 0x02f2, 0x02f2, 0x0000,
-	0x02f7, 0x0000, 0x02f9, 0x02f9, 0x02f9, 0x02f9, 0x02f9, 0x0000,
-	// Entry 300 - 33F
-	0x02ff, 0x0300, 0x02ff, 0x0000, 0x0303, 0x0051, 0x00e6,
-} // Size: 1574 bytes
-
-// Total table size 1574 bytes (1KiB); checksum: 895AAF0B