diff --git a/.gitignore b/.gitignore
index 44e5f6d..55a6153 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,6 @@
 # Coverage and profiles
 *.out
 *.cdx.json
+
+# Downloaded source data (Unicode, WindowsBestFit); only generated tables are committed
+/.cache/
diff --git a/internal/pathrule/gen/main.go b/internal/pathrule/gen/main.go
new file mode 100644
index 0000000..5835f1c
--- /dev/null
+++ b/internal/pathrule/gen/main.go
@@ -0,0 +1,573 @@
+// Command gen generates the Unicode and best-fit tables of package pathrule
+// (spec §29.5.1) from the data files of Unicode 18.0.0 and WindowsBestFit:
+//
+//	go run ./internal/pathrule/gen -data .cache
+//
+// It reads, below the -data directory,
+//
+//	unicode/18.0.0/UnicodeData.txt
+//	unicode/18.0.0/DerivedCoreProperties.txt
+//	unicode/18.0.0/CaseFolding.txt
+//	unicode/18.0.0/emoji/emoji-variation-sequences.txt
+//	bestfit/bestfit<N>.txt, for the 15 code pages of WindowsBestFit
+//
+// checks the SHA-256 of each against the value pinned below, and writes
+// internal/pathrule/tables.go. The files are not in the repository: only the
+// generated tables are. Download them from https://www.unicode.org/Public/.
+//
+// The tables are also described by a canonical text, whose SHA-256 is
+// TablesDigest: an implementation in another language generated from the
+// same files computes the same digest (see canonical in package pathrule).
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"flag"
+	"fmt"
+	"go/format"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+// UnicodeVersion is the version of Unicode the tables come from (spec
+// §29.5.1). It is fixed with capsule format 3.
+const UnicodeVersion = "18.0.0"
+
+// source is one data file and the SHA-256 it must have.
+type source struct {
+	path, sha256 string
+}
+
+// The pinned files (spec §29.5.1).
+var (
+	unicodeData   = source{"unicode/18.0.0/UnicodeData.txt", "0736451de439ae7baf1425136617da495e09ee5afbe6e394374db7009ea08950"}
+	derivedCore   = source{"unicode/18.0.0/DerivedCoreProperties.txt", "09c928886a178fcafd93c29e4bd59073a058e5a100b716d425cb563ab50f68c9"}
+	caseFolding   = source{"unicode/18.0.0/CaseFolding.txt", "a004797658a457bec4dc11683e39f69249ea3b595b752dbea6721c4c9f587b0d"}
+	emojiVariants = source{"unicode/18.0.0/emoji/emoji-variation-sequences.txt", "ff1707564aa1f1b2fcf4ec92d609d4cb26940bc0d4dcf07f5328ad6879e84da3"}
+	bestFitFiles  = []source{
+		{"bestfit/bestfit874.txt", "663f43ca662e037c4534cb16298b560f29ce29c27b49b3589601ec3d97dd89fd"},
+		{"bestfit/bestfit932.txt", "2614cfea35c3c86c41d33198793a84ca44edee3cf0ee0013a61a43fba4ece331"},
+		{"bestfit/bestfit936.txt", "e5070a2d6ad26619f5872ddbe64d3381c11620af5adbb04cda0f0abb1a91fdae"},
+		{"bestfit/bestfit949.txt", "50e13b60ea8fda66a8223ecc85270e0f182303222244e2345d3d57f3e839d20a"},
+		{"bestfit/bestfit950.txt", "cf8c23389a42a226ea707f7ec32c665556d1fc3364db25bd765ce64d54eaee2a"},
+		{"bestfit/bestfit1250.txt", "cef9f171e67b09445bcb3f9ffccdc89418250ff825f1bd2d29a92d2074d7a53b"},
+		{"bestfit/bestfit1251.txt", "59ec85612ff908d9da0e877893c935941e56b13a2882b4fb9c9599be3d1ce4e7"},
+		{"bestfit/bestfit1252.txt", "72ea23c939c5b26fae7aded0207b327e2f3902d7d3c168d7087f5cfc38ee76a9"},
+		{"bestfit/bestfit1253.txt", "ea80c442aff7f09b36da6335f85f8e527f51c146beeb9825ec00d1b6ca99a99e"},
+		{"bestfit/bestfit1254.txt", "3d02512087634dc493b720992b590277736ffb2d5b0b665d69b6b9727e2c361a"},
+		{"bestfit/bestfit1255.txt", "fdd4bdda74f6571d89171b0070ac052cd3714c395dc3d1799bcd5e4a4da6f83a"},
+		{"bestfit/bestfit1256.txt", "745c447ada04a838da8bea406c13f446c7453b6371e8c6c7863a632443d56007"},
+		{"bestfit/bestfit1257.txt", "b8c5d7f3b8c25c3d5625d44dd3d6ee7a06e652ddf77373d050282c1cb7517366"},
+		{"bestfit/bestfit1258.txt", "5d52a9357b7d6b5b5014ed5a51be0ff9809b0c33625793d2a4feaf502e0682f1"},
+		{"bestfit/bestfit1361.txt", "7dcda2d5d2cfc5ddf43757d589a0106e020ef0d9b84de47f08e18297ae0fe1ec"},
+	}
+)
+
+func main() {
+	data := flag.String("data", ".cache", "directory with the downloaded data files")
+	out := flag.String("go", "internal/pathrule/tables.go", "Go file to write")
+	flag.Parse()
+	t, err := build(*data)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "gen:", err)
+		os.Exit(1)
+	}
+	src, err := t.goSource()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "gen:", err)
+		os.Exit(1)
+	}
+	if err := os.WriteFile(*out, src, 0o644); err != nil {
+		fmt.Fprintln(os.Stderr, "gen:", err)
+		os.Exit(1)
+	}
+	fmt.Printf("wrote %s: %d assigned ranges, %d ignorable ranges, %d ccc, %d decompositions, %d foldings, %d+%d emoji bases, %d best-fit tables; digest %s\n",
+		*out, len(t.assigned), len(t.ignorable), len(t.ccc), len(t.decomp), len(t.fold), len(t.vs15), len(t.vs16), len(t.bestFit), t.digest())
+}
+
+// tables are the data package pathrule needs, in canonical order.
+type tables struct {
+	assigned  [][2]rune       // ranges of assigned code points
+	ignorable [][2]rune       // ranges of Default_Ignorable_Code_Point
+	ccc       map[rune]uint8  // canonical combining class, non-zero only
+	decomp    map[rune][]rune // full canonical decomposition, Hangul excluded
+	fold      map[rune][]rune // case folding, statuses C and F
+	vs15      []rune          // bases of an emoji variation sequence with U+FE0E
+	vs16      []rune          // bases of an emoji variation sequence with U+FE0F
+	bestFit   []bestFitTable  // one per code page
+	sources   []source        // the files, for the record
+}
+
+type bestFitTable struct {
+	name string        // code page, "874"
+	to   map[rune]byte // non-ASCII code point -> ASCII byte
+}
+
+// read returns the contents of a data file after checking its digest.
+func read(dir string, s source) ([]byte, error) {
+	b, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(s.path)))
+	if err != nil {
+		return nil, err
+	}
+	sum := sha256.Sum256(b)
+	if got := hex.EncodeToString(sum[:]); got != s.sha256 {
+		return nil, fmt.Errorf("%s: SHA-256 %s, want %s", s.path, got, s.sha256)
+	}
+	return b, nil
+}
+
+func build(dir string) (*tables, error) {
+	t := &tables{ccc: map[rune]uint8{}, decomp: map[rune][]rune{}, fold: map[rune][]rune{}}
+	t.sources = append([]source{unicodeData, derivedCore, caseFolding, emojiVariants}, bestFitFiles...)
+
+	b, err := read(dir, unicodeData)
+	if err != nil {
+		return nil, err
+	}
+	if err := t.parseUnicodeData(b); err != nil {
+		return nil, fmt.Errorf("%s: %w", unicodeData.path, err)
+	}
+	if b, err = read(dir, derivedCore); err != nil {
+		return nil, err
+	}
+	if t.ignorable, err = parseProperty(b, "Default_Ignorable_Code_Point"); err != nil {
+		return nil, fmt.Errorf("%s: %w", derivedCore.path, err)
+	}
+	if b, err = read(dir, caseFolding); err != nil {
+		return nil, err
+	}
+	if err := t.parseCaseFolding(b); err != nil {
+		return nil, fmt.Errorf("%s: %w", caseFolding.path, err)
+	}
+	if b, err = read(dir, emojiVariants); err != nil {
+		return nil, err
+	}
+	if err := t.parseEmojiVariants(b); err != nil {
+		return nil, fmt.Errorf("%s: %w", emojiVariants.path, err)
+	}
+	for _, s := range bestFitFiles {
+		if b, err = read(dir, s); err != nil {
+			return nil, err
+		}
+		bt, err := parseBestFit(b)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", s.path, err)
+		}
+		bt.name = strings.TrimSuffix(strings.TrimPrefix(filepath.Base(s.path), "bestfit"), ".txt")
+		t.bestFit = append(t.bestFit, bt)
+	}
+	return t, nil
+}
+
+func hexRune(s string) (rune, error) {
+	v, err := strconv.ParseUint(strings.TrimSpace(s), 16, 32)
+	if err != nil || v > 0x10FFFF {
+		return 0, fmt.Errorf("bad code point %q", s)
+	}
+	return rune(v), nil
+}
+
+func hexRunes(s string) ([]rune, error) {
+	var out []rune
+	for _, f := range strings.Fields(s) {
+		r, err := hexRune(f)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, r)
+	}
+	return out, nil
+}
+
+// lines yields the data lines of a UCD-style file: comments after '#'
+// removed, blank lines skipped.
+func lines(b []byte, f func(line string) error) error {
+	sc := bufio.NewScanner(bytes.NewReader(b))
+	sc.Buffer(make([]byte, 1<<16), 1<<20)
+	for n := 1; sc.Scan(); n++ {
+		line := sc.Text()
+		if i := strings.IndexByte(line, '#'); i >= 0 {
+			line = line[:i]
+		}
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		if err := f(line); err != nil {
+			return fmt.Errorf("line %d: %w", n, err)
+		}
+	}
+	return sc.Err()
+}
+
+func (t *tables) parseUnicodeData(b []byte) error {
+	canonical := map[rune][]rune{}
+	var assigned []rune
+	var first rune = -1
+	err := lines(b, func(line string) error {
+		f := strings.Split(line, ";")
+		if len(f) != 15 {
+			return fmt.Errorf("%d fields", len(f))
+		}
+		cp, err := hexRune(f[0])
+		if err != nil {
+			return err
+		}
+		switch name := f[1]; {
+		case strings.HasSuffix(name, ", First>"):
+			first = cp
+			return nil
+		case strings.HasSuffix(name, ", Last>"):
+			if first < 0 {
+				return fmt.Errorf("range end %04X without start", cp)
+			}
+			for r := first; r <= cp; r++ {
+				assigned = append(assigned, r)
+			}
+			first = -1
+		default:
+			assigned = append(assigned, cp)
+		}
+		if c, err := strconv.ParseUint(f[3], 10, 8); err != nil {
+			return fmt.Errorf("ccc %q", f[3])
+		} else if c != 0 {
+			t.ccc[cp] = uint8(c)
+		}
+		if d := f[5]; d != "" && !strings.HasPrefix(d, "<") {
+			m, err := hexRunes(d)
+			if err != nil {
+				return err
+			}
+			canonical[cp] = m
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	t.assigned = ranges(assigned)
+	var expand func(r rune) []rune
+	expand = func(r rune) []rune {
+		m, ok := canonical[r]
+		if !ok {
+			return []rune{r}
+		}
+		var out []rune
+		for _, x := range m {
+			out = append(out, expand(x)...)
+		}
+		return out
+	}
+	for r := range canonical {
+		t.decomp[r] = expand(r)
+	}
+	return nil
+}
+
+// ranges turns a set of code points into sorted, merged, inclusive ranges.
+func ranges(cps []rune) [][2]rune {
+	slices.Sort(cps)
+	cps = slices.Compact(cps)
+	var out [][2]rune
+	for _, r := range cps {
+		if n := len(out); n > 0 && out[n-1][1]+1 == r {
+			out[n-1][1] = r
+			continue
+		}
+		out = append(out, [2]rune{r, r})
+	}
+	return out
+}
+
+func parseProperty(b []byte, name string) ([][2]rune, error) {
+	var cps []rune
+	err := lines(b, func(line string) error {
+		f := strings.SplitN(line, ";", 2)
+		if len(f) != 2 || strings.TrimSpace(f[1]) != name {
+			return nil
+		}
+		lo, hi, ok := strings.Cut(strings.TrimSpace(f[0]), "..")
+		a, err := hexRune(lo)
+		if err != nil {
+			return err
+		}
+		z := a
+		if ok {
+			if z, err = hexRune(hi); err != nil {
+				return err
+			}
+		}
+		for r := a; r <= z; r++ {
+			cps = append(cps, r)
+		}
+		return nil
+	})
+	if len(cps) == 0 && err == nil {
+		err = fmt.Errorf("no %s entries", name)
+	}
+	return ranges(cps), err
+}
+
+func (t *tables) parseCaseFolding(b []byte) error {
+	return lines(b, func(line string) error {
+		f := strings.Split(line, ";")
+		if len(f) < 3 {
+			return fmt.Errorf("%d fields", len(f))
+		}
+		switch strings.TrimSpace(f[1]) {
+		case "C", "F":
+		default:
+			return nil
+		}
+		cp, err := hexRune(f[0])
+		if err != nil {
+			return err
+		}
+		m, err := hexRunes(f[2])
+		if err != nil {
+			return err
+		}
+		if _, dup := t.fold[cp]; dup {
+			return fmt.Errorf("two C or F foldings for %04X", cp)
+		}
+		t.fold[cp] = m
+		return nil
+	})
+}
+
+func (t *tables) parseEmojiVariants(b []byte) error {
+	err := lines(b, func(line string) error {
+		f := strings.SplitN(line, ";", 2)
+		seq, err := hexRunes(f[0])
+		if err != nil {
+			return err
+		}
+		if len(seq) != 2 {
+			return fmt.Errorf("sequence of %d code points", len(seq))
+		}
+		switch seq[1] {
+		case 0xFE0E:
+			t.vs15 = append(t.vs15, seq[0])
+		case 0xFE0F:
+			t.vs16 = append(t.vs16, seq[0])
+		default:
+			return fmt.Errorf("selector %04X", seq[1])
+		}
+		return nil
+	})
+	slices.Sort(t.vs15)
+	slices.Sort(t.vs16)
+	t.vs15, t.vs16 = slices.Compact(t.vs15), slices.Compact(t.vs16)
+	return err
+}
+
+// parseBestFit keeps, from the WCTABLE section, the code points of 0x80 and
+// above that the code page maps to a single ASCII byte (spec §29.5, R6c).
+func parseBestFit(b []byte) (bestFitTable, error) {
+	bt := bestFitTable{to: map[rune]byte{}}
+	sc := bufio.NewScanner(bytes.NewReader(b))
+	in, seen := false, false
+	for n := 1; sc.Scan(); n++ {
+		line := sc.Text()
+		if i := strings.IndexByte(line, ';'); i >= 0 {
+			line = line[:i]
+		}
+		f := strings.Fields(line)
+		if len(f) == 0 {
+			continue
+		}
+		if !strings.HasPrefix(f[0], "0x") {
+			in = f[0] == "WCTABLE"
+			seen = seen || in
+			continue
+		}
+		if !in {
+			continue
+		}
+		if len(f) < 2 {
+			return bt, fmt.Errorf("line %d: %q", n, line)
+		}
+		u, err1 := strconv.ParseUint(f[0][2:], 16, 32)
+		v, err2 := strconv.ParseUint(strings.TrimPrefix(f[1], "0x"), 16, 32)
+		if err1 != nil || err2 != nil || u > 0xFFFF {
+			return bt, fmt.Errorf("line %d: %q", n, line)
+		}
+		if u >= 0x80 && v <= 0x7F {
+			bt.to[rune(u)] = byte(v)
+		}
+	}
+	if !seen {
+		return bt, fmt.Errorf("no WCTABLE section")
+	}
+	return bt, sc.Err()
+}
+
+func sortedKeys[V any](m map[rune]V) []rune {
+	keys := make([]rune, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	slices.Sort(keys)
+	return keys
+}
+
+// canonical is the text whose SHA-256 is TablesDigest. Package pathrule
+// rebuilds it from the generated tables, and so does any other
+// implementation, line by line: every value in upper-case hexadecimal of at
+// least four digits, except the combining class and the code page, in
+// decimal.
+func (t *tables) canonical() string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "unicode %s\n", UnicodeVersion)
+	for _, r := range t.assigned {
+		fmt.Fprintf(&b, "assigned %04X %04X\n", r[0], r[1])
+	}
+	for _, r := range t.ignorable {
+		fmt.Fprintf(&b, "ignorable %04X %04X\n", r[0], r[1])
+	}
+	for _, k := range sortedKeys(t.ccc) {
+		fmt.Fprintf(&b, "ccc %04X %d\n", k, t.ccc[k])
+	}
+	for _, k := range sortedKeys(t.decomp) {
+		fmt.Fprintf(&b, "decomp %04X%s\n", k, hexList(t.decomp[k]))
+	}
+	for _, k := range sortedKeys(t.fold) {
+		fmt.Fprintf(&b, "fold %04X%s\n", k, hexList(t.fold[k]))
+	}
+	for _, r := range t.vs15 {
+		fmt.Fprintf(&b, "vs15 %04X\n", r)
+	}
+	for _, r := range t.vs16 {
+		fmt.Fprintf(&b, "vs16 %04X\n", r)
+	}
+	for _, bt := range t.bestFit {
+		for _, k := range sortedKeys(bt.to) {
+			fmt.Fprintf(&b, "bestfit %s %04X %02X\n", bt.name, k, bt.to[k])
+		}
+	}
+	return b.String()
+}
+
+func hexList(rs []rune) string {
+	var b strings.Builder
+	for _, r := range rs {
+		fmt.Fprintf(&b, " %04X", r)
+	}
+	return b.String()
+}
+
+func (t *tables) digest() string {
+	sum := sha256.Sum256([]byte(t.canonical()))
+	return hex.EncodeToString(sum[:])
+}
+
+// goSource renders tables.go.
+func (t *tables) goSource() ([]byte, error) {
+	var b bytes.Buffer
+	w := func(format string, args ...any) { fmt.Fprintf(&b, format, args...) }
+	w("// Code generated by internal/pathrule/gen from Unicode %s and WindowsBestFit. DO NOT EDIT.\n\n", UnicodeVersion)
+	w("package pathrule\n\n")
+	w("// UnicodeVersion is the version of Unicode of these tables, fixed with\n// capsule format 3 (spec §29.5.1).\nconst UnicodeVersion = %q\n\n", UnicodeVersion)
+	w("// TablesDigest is the SHA-256 of the canonical text of these tables (see\n// Canonical). Another implementation generated from the same files has it too.\nconst TablesDigest = %q\n\n", t.digest())
+	w("// Sources are the data files of the tables and their SHA-256 (spec §29.5.1).\nvar Sources = []struct{ Path, SHA256 string }{\n")
+	for _, s := range t.sources {
+		w("\t{%q, %q},\n", s.path, s.sha256)
+	}
+	w("}\n\n")
+
+	pairs := func(name, doc string, rs [][2]rune) {
+		w("// %s\nvar %s = []rune{", doc, name)
+		for i, r := range rs {
+			if i%6 == 0 {
+				w("\n\t")
+			}
+			w("0x%04X, 0x%04X, ", r[0], r[1])
+		}
+		w("\n}\n\n")
+	}
+	pairs("assignedRanges", "assignedRanges are the assigned code points, as inclusive ranges: lo, hi, ...", t.assigned)
+	pairs("ignorableRanges", "ignorableRanges are Default_Ignorable_Code_Point, as inclusive ranges.", t.ignorable)
+
+	w("// cccTable holds each code point with a non-zero canonical combining class,\n// as code point << 8 | class, sorted.\nvar cccTable = []uint32{")
+	for i, k := range sortedKeys(t.ccc) {
+		if i%8 == 0 {
+			w("\n\t")
+		}
+		w("0x%06X, ", uint32(k)<<8|uint32(t.ccc[k]))
+	}
+	w("\n}\n\n")
+
+	mapping := func(name, doc string, m map[rune][]rune) {
+		keys := sortedKeys(m)
+		w("// %s\nvar %s = mapping{\n\tkeys: []rune{", doc, name)
+		for i, k := range keys {
+			if i%10 == 0 {
+				w("\n\t\t")
+			}
+			w("0x%04X, ", k)
+		}
+		w("\n\t},\n\tstart: []uint16{")
+		n := 0
+		for i, k := range keys {
+			if i%12 == 0 {
+				w("\n\t\t")
+			}
+			w("%d, ", n)
+			n += len(m[k])
+		}
+		w("%d,\n\t},\n\tdata: []rune{", n)
+		i := 0
+		for _, k := range keys {
+			for _, r := range m[k] {
+				if i%10 == 0 {
+					w("\n\t\t")
+				}
+				w("0x%04X, ", r)
+				i++
+			}
+		}
+		w("\n\t},\n}\n\n")
+	}
+	mapping("decompositions", "decompositions is the full canonical decomposition of each code point that has\n// one, Hangul syllables excepted.", t.decomp)
+	mapping("foldings", "foldings is the case folding of CaseFolding.txt, statuses C and F.", t.fold)
+
+	set := func(name, doc string, rs []rune) {
+		w("// %s\nvar %s = []rune{", doc, name)
+		for i, r := range rs {
+			if i%10 == 0 {
+				w("\n\t")
+			}
+			w("0x%04X, ", r)
+		}
+		w("\n}\n\n")
+	}
+	set("vs15Bases", "vs15Bases are the characters of an emoji variation sequence with U+FE0E.", t.vs15)
+	set("vs16Bases", "vs16Bases are the characters of an emoji variation sequence with U+FE0F.", t.vs16)
+
+	w("// bestFitTables are, for each code page of WindowsBestFit, the code points\n// of U+0080 and above that it maps to a single ASCII byte.\nvar bestFitTables = []bestFitTable{\n")
+	for _, bt := range t.bestFit {
+		keys := sortedKeys(bt.to)
+		w("\t{\n\t\tname: %q,\n\t\tfrom: []rune{", bt.name)
+		for i, k := range keys {
+			if i%10 == 0 {
+				w("\n\t\t\t")
+			}
+			w("0x%04X, ", k)
+		}
+		w("\n\t\t},\n\t\tto: []byte{")
+		for i, k := range keys {
+			if i%16 == 0 {
+				w("\n\t\t\t")
+			}
+			w("0x%02X, ", bt.to[k])
+		}
+		w("\n\t\t},\n\t},\n")
+	}
+	w("}\n")
+	return format.Source(b.Bytes())
+}
diff --git a/internal/pathrule/pathrule_test.go b/internal/pathrule/pathrule_test.go
new file mode 100644
index 0000000..5c929c2
--- /dev/null
+++ b/internal/pathrule/pathrule_test.go
@@ -0,0 +1,268 @@
+package pathrule
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The generated tables match their canonical text: nobody edited them.
+func TestTablesDigest(t *testing.T) {
+	if got := digest(); got != TablesDigest {
+		t.Fatalf("digest of the tables %s, TablesDigest %s", got, TablesDigest)
+	}
+	if UnicodeVersion != "18.0.0" {
+		t.Fatalf("UnicodeVersion %q", UnicodeVersion)
+	}
+	if len(Sources) != 19 || len(bestFitTables) != 15 {
+		t.Fatalf("%d sources, %d best-fit tables", len(Sources), len(bestFitTables))
+	}
+}
+
+func TestProperties(t *testing.T) {
+	for _, c := range []struct {
+		r                   rune
+		assigned, ignorable bool
+	}{
+		{'a', true, false},
+		{0x0378, false, false}, // unassigned
+		{0x00AD, true, true},   // soft hyphen
+		{0x200D, true, true},   // ZWJ
+		{0xFE0F, true, true},   // VS16
+		{0x206A, true, true},   // deprecated format character
+		{0xE0041, true, true},  // tag A
+		{0xE0000, false, true}, // unassigned, still ignorable
+		{0x2028, true, false},  // line separator
+		{0xFFFE, false, false}, // noncharacter
+		{0xF03A, true, false},  // private use
+		{0x10FFFF, false, false},
+	} {
+		if Assigned(c.r) != c.assigned || DefaultIgnorable(c.r) != c.ignorable {
+			t.Errorf("U+%04X: assigned %v ignorable %v, want %v %v", c.r, Assigned(c.r), DefaultIgnorable(c.r), c.assigned, c.ignorable)
+		}
+	}
+}
+
+func TestNFD(t *testing.T) {
+	for _, c := range []struct{ in, want string }{
+		{"é", "é"},
+		{"Å", "Å"},    // ANGSTROM SIGN, a singleton decomposition
+		{"K", "K"},     // KELVIN SIGN
+		{"한", "한"},   // Hangul, with a final jamo
+		{"하", "하"},    // Hangul, without
+		{"ạ́", "ạ́"}, // canonical order
+		{"ΐ", "ΐ"},
+		{"ǖ", "ǖ"},     // recursive decomposition
+		{"á‍̣", "á‍̣"}, // ZWJ is a starter
+	} {
+		if got := NFD(c.in); got != c.want {
+			t.Errorf("NFD(%+q) = %+q, want %+q", c.in, got, c.want)
+		}
+	}
+}
+
+func TestKey(t *testing.T) {
+	for _, same := range [][2]string{
+		{"A.txt", "a.txt"},
+		{"Straße", "STRASSE"},
+		{"K", "k"},
+		{"ı", "i"},
+		{"é", "é"},
+		{"ab", "a‌b"},
+		{"á‍̣", "ạ́"},
+		{".DateKeys-x", ".datekeys-x"},
+	} {
+		if Key(same[0]) != Key(same[1]) {
+			t.Errorf("Key(%+q) = %+q, Key(%+q) = %+q", same[0], Key(same[0]), same[1], Key(same[1]))
+		}
+	}
+	if Key("a") == Key("b") {
+		t.Error("distinct keys expected")
+	}
+}
+
+// rule is the rule of a pathrule error, "" for nil.
+func rule(err error) string {
+	var e *Error
+	if errors.As(err, &e) {
+		return e.Rule
+	}
+	if err != nil {
+		return "?" + err.Error()
+	}
+	return ""
+}
+
+func TestCheckPath(t *testing.T) {
+	const (
+		zwj  = "‍"
+		zwnj = "‌"
+		vs16 = "️"
+	)
+	scotland := "\U0001F3F4\U000E0067\U000E0062\U000E0073\U000E0063\U000E0074\U000E007F"
+	for _, c := range []struct {
+		path, rule string
+	}{
+		// Accepted.
+		{"nota.txt", ""},
+		{"fotos/playa.jpg", ""},
+		{"¿Qué es esto.jpg", ""},                       // bestfit1250 maps ¿ to '?', which R6c no longer rejects
+		{"Para ti ♥.jpg", ""},                          // bestfit874 maps ♥ to 0x03
+		{"§ 3 contrato.pdf", ""},                       // bestfit874 maps § to 0x15
+		{"Madrid → Lisboa", ""},                        // bestfit1253 maps → to '>'
+		{"❤" + vs16 + ".txt", ""},                      // ❤️
+		{"\U0001F3F3" + vs16 + zwj + "\U0001F308", ""}, // rainbow flag
+		{"\U0001F468" + zwj + "\U0001F469" + zwj + "\U0001F467", ""},
+		{"ab" + zwnj + "c", ""},
+		{"a/.datekeys-x", ""}, // only the first segment is reserved
+		{"ABCDEFGHI~1", ""},   // longer than 8 before the dot
+		{"a~1b", ""},
+		{"report~2023.txt", ""},
+		{strings.Repeat("a", 255), ""},
+		{strings.Repeat("ΐ", 85), ""}, // 170 bytes, 255 UTF-16 units after NFD
+		{" a ", ""},                   // no table maps U+00A0 to U+0020... checked below
+
+		// R2.
+		{"/a", "R2"},
+		{"a//b", "R2"},
+		{"a/", "R2"},
+		{strings.Repeat("a/", 32) + "a", "R2"},
+		// R3.
+		{"..", "R3"},
+		{"a/./b", "R3"},
+		{zwj, "R4b"}, // R3 sees an empty stripped segment? No: R3 first.
+		{strings.Repeat("a", 256), "R3"},
+		{strings.Repeat("ΐ", 127), "R3"}, // 254 bytes, 381 UTF-16 units after NFD
+		// R4.
+		{"a:b", "R4"},
+		{"a\\b", "R4"},
+		{"a?b", "R4"},
+		{"a\tb", "R4"},
+		{"a
b", "R4"},
+		{"a­b", "R4"},
+		{"ab", "R4"},
+		{"a‮b", "R4"},
+		{"informeanexo", "R4"},
+		{"a͸b", "R4"},
+		{"a￾b", "R4"},
+		{scotland, "R4"},
+		{"\U0001F600\U000E0100", "R4"}, // VS17
+		// R4b.
+		{"a" + vs16, "R4b"},
+		{zwj + "a", "R4b"},
+		{"a" + zwj, "R4b"},
+		{"a" + zwj + zwj + "b", "R4b"},
+		{"a" + zwnj + zwj + "b", "R4b"},
+		// R5.
+		{" a", "R5"},
+		{"a ", "R5"},
+		{"a.", "R5"},
+		// R6.
+		{"CON.txt", "R6"},
+		{"con", "R6"},
+		{"Aux .log", "R6"},
+		{"COM¹", "R6"},
+		{"lpt9.doc", "R6"},
+		{"CONIN$", "R6"},
+		// R6b.
+		{"ABCDEF~1", "R6b"},
+		{"ABCDEF~1.TXT", "R6b"},
+		{"~1", "R6b"},
+		{"Ä~1.txt", "R6b"},
+		// R6c.
+		{"ＣＯＮ.txt", "R6c"}, // full-width CON
+		{"a∖b", "R6c"},     // SET MINUS
+		{"a∶b", "R6c"},     // RATIO
+		{"　a", "R6c"},      // bestfit1252 maps U+3000 to U+0020, which breaks R5
+		{"a／b", "R6c"},     // full-width solidus
+		{"．．", "R6c"},      // full-width dots project to ".."
+		// R10.
+		{".datekeys-x", "R10"},
+		{".DateKeys-abc/b", "R10"},
+	} {
+		got := rule(CheckPath(c.path))
+		if c.path == zwj {
+			// R3 comes before R4b in a segment: the stripped segment is empty.
+			if got != "R3" {
+				t.Errorf("CheckPath(%+q): %s, want R3", c.path, got)
+			}
+			continue
+		}
+		if c.path == " a " {
+			// Whatever the tables give, it must be R6c or nothing (R5 is
+			// about U+0020 only).
+			if got != "" && got != "R6c" {
+				t.Errorf("CheckPath(%+q): %s", c.path, got)
+			}
+			continue
+		}
+		if got != c.rule {
+			t.Errorf("CheckPath(%+q): %s (%v), want %s", c.path, got, CheckPath(c.path), c.rule)
+		}
+	}
+}
+
+func TestCheckTree(t *testing.T) {
+	for _, c := range []struct {
+		paths []string
+		rule  string
+	}{
+		{[]string{"a/b", "a/c", "d"}, ""},
+		{[]string{"A.txt", "a.txt"}, "R7"},
+		{[]string{"A", "a/b"}, "R7"},
+		{[]string{"a/b", "a/b/c"}, "R7"},
+		{[]string{"Fotos/b", "fotos/a"}, "R7"},
+		{[]string{"STRASSE", "Straße"}, "R7"},
+		{[]string{"ab", "a‌b"}, "R7"},
+		{[]string{"k", "K"}, "R7"},
+	} {
+		if got := rule(CheckTree(c.paths)); got != c.rule {
+			t.Errorf("CheckTree(%+q): %s, want %s", c.paths, got, c.rule)
+		}
+	}
+	many := make([]string, MaxImplicitDirs+1)
+	for i := range many {
+		many[i] = fmt.Sprintf("d%05d/f", i)
+	}
+	if got := rule(CheckTree(many)); got != "R9" {
+		t.Errorf("%d folders: %s, want R9", len(many), got)
+	}
+	if got := rule(CheckTree(many[:MaxImplicitDirs])); got != "" {
+		t.Errorf("%d folders: %s", MaxImplicitDirs, got)
+	}
+}
+
+func TestTexts(t *testing.T) {
+	for _, c := range []struct {
+		text    string
+		comment bool
+		rule    string
+	}{
+		{"Hola\tmundo\nsegunda línea", true, ""},
+		{"❤️ para ti", true, ""},
+		{"Hola\r\n", true, "text"},
+		{"a‮b", true, "text"},
+		{"Hola\U000E0049\U000E0047", true, "text"}, // tag characters
+		{"\U0001F600\U000E0100", true, "text"},     // VS17
+		{"a️", true, "text"},                       // VS16 after a letter
+		{"a‍\nb", true, "text"},                    // ZWJ at the end of a line
+		{"a￾", true, "text"},
+		{"a﷐", true, "text"},
+		{"a­b", true, "text"},
+		{"Ana López", false, ""},
+		{"Ana\tLópez", false, "text"},
+		{"Ana\nLópez", false, "text"},
+		{" Ana", false, "text"},
+		{"Ana ", false, "text"},
+		{"a‎b", false, "text"},
+	} {
+		check := CheckAuthor
+		if c.comment {
+			check = CheckComment
+		}
+		if got := rule(check(c.text)); got != c.rule {
+			t.Errorf("%+q (comment %v): %s, want %s", c.text, c.comment, got, c.rule)
+		}
+	}
+}
diff --git a/internal/pathrule/rules.go b/internal/pathrule/rules.go
new file mode 100644
index 0000000..c0e070a
--- /dev/null
+++ b/internal/pathrule/rules.go
@@ -0,0 +1,392 @@
+package pathrule
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"unicode/utf8"
+)
+
+// Limits of the paths and texts of a format 3 head, fixed with the format
+// (spec §29.4, §29.5).
+const (
+	MaxPathLen        = 1024  // R1, bytes
+	MaxSegments       = 32    // R2
+	MaxSegmentLen     = 255   // R3, bytes
+	MaxSegmentUTF16   = 255   // R3, UTF-16 code units of the NFD of the segment
+	MaxImplicitDirs   = 65535 // R9
+	MaxCommentLen     = 16384 // bytes
+	MaxAuthorLen      = 256   // bytes
+	reservedDirPrefix = ".datekeys-"
+)
+
+// Error is the violation of one rule of spec §29.5 or §29.6. Its text is
+// the same in every implementation, so that the message of a rejected head
+// does not depend on the reader.
+type Error struct {
+	Rule   string // "R2" to "R10", "text"
+	Detail string
+}
+
+func (e *Error) Error() string { return e.Rule + ": " + e.Detail }
+
+func fail(rule, format string, args ...any) error {
+	return &Error{Rule: rule, Detail: fmt.Sprintf(format, args...)}
+}
+
+// codePoint formats r as in the spec: U+ and at least four upper-case
+// hexadecimal digits.
+func codePoint(r rune) string { return fmt.Sprintf("U+%04X", r) }
+
+// forbiddenASCII are the ASCII characters of R4 that are not controls.
+const forbiddenASCII = `"*:<>?\|`
+
+// CheckPath checks one path of the head with the rules of the fourth layer
+// that concern it alone, in this order: R2, and then for each segment R3,
+// R4, R4b, R5, R6, R6b and R6c; then R10. R1 and R8 belong to the third
+// layer, and R7 and R9 to the whole tree (CheckTree). The first violation
+// is returned.
+func CheckPath(path string) error {
+	segs := strings.Split(path, "/")
+	if len(segs) > MaxSegments {
+		return fail("R2", "%d segments, more than %d", len(segs), MaxSegments)
+	}
+	for i, s := range segs {
+		if s == "" {
+			return fail("R2", "segment %d is empty", i+1)
+		}
+	}
+	for i, s := range segs {
+		if err := checkSegment(s); err != nil {
+			e := err.(*Error)
+			e.Detail = fmt.Sprintf("segment %d: %s", i+1, e.Detail)
+			return e
+		}
+	}
+	if strings.HasPrefix(Key(segs[0]), reservedDirPrefix) {
+		return fail("R10", "the first segment starts with %q", reservedDirPrefix)
+	}
+	return nil
+}
+
+// checkSegment applies R3, R4, R4b, R5, R6, R6b and R6c to a segment.
+func checkSegment(s string) error {
+	if err := checkR3(s); err != nil {
+		return err
+	}
+	for _, r := range s {
+		if err := checkR4(r); err != nil {
+			return err
+		}
+	}
+	if err := checkPlacement("R4b", s); err != nil {
+		return err
+	}
+	if err := checkR5(s); err != nil {
+		return err
+	}
+	if err := checkR6(s); err != nil {
+		return err
+	}
+	if err := checkR6b(s); err != nil {
+		return err
+	}
+	return checkR6c(s)
+}
+
+func checkR3(s string) error {
+	if len(s) > MaxSegmentLen {
+		return fail("R3", "%d bytes, more than %d", len(s), MaxSegmentLen)
+	}
+	switch s {
+	case ".":
+		return fail("R3", "the segment is a dot")
+	case "..":
+		return fail("R3", "the segment is two dots")
+	}
+	switch stripWhitelist(s) {
+	case "":
+		return fail("R3", "the segment is empty without ZWNJ, ZWJ, VS15 and VS16")
+	case ".":
+		return fail("R3", "the segment is a dot without ZWNJ, ZWJ, VS15 and VS16")
+	case "..":
+		return fail("R3", "the segment is two dots without ZWNJ, ZWJ, VS15 and VS16")
+	}
+	if n := utf16Len(NFD(s)); n > MaxSegmentUTF16 {
+		return fail("R3", "its NFD is %d UTF-16 code units, more than %d", n, MaxSegmentUTF16)
+	}
+	return nil
+}
+
+func utf16Len(s string) int {
+	n := 0
+	for _, r := range s {
+		if r >= 0x10000 {
+			n += 2
+		} else {
+			n++
+		}
+	}
+	return n
+}
+
+// checkR4 rejects the code points of R4.
+func checkR4(r rune) error {
+	switch {
+	case r <= 0x1F || (r >= 0x7F && r <= 0x9F):
+		return fail("R4", "control %s", codePoint(r))
+	case strings.ContainsRune(forbiddenASCII, r):
+		return fail("R4", "character %s", codePoint(r))
+	case r == 0x2028 || r == 0x2029:
+		return fail("R4", "separator %s", codePoint(r))
+	case DefaultIgnorable(r) && !whitelisted(r):
+		return fail("R4", "invisible %s", codePoint(r))
+	case r >= 0xF000 && r <= 0xF0FF:
+		return fail("R4", "private use %s", codePoint(r))
+	case !Assigned(r):
+		return fail("R4", "unassigned %s", codePoint(r))
+	}
+	return nil
+}
+
+// checkPlacement applies R4b to s, a segment or a line of a text: VS15 and
+// VS16 only right after a character that forms an emoji variation sequence
+// with them, and ZWJ and ZWNJ never first, last or right after another ZWJ
+// or ZWNJ.
+func checkPlacement(rule, s string) error {
+	prev, i := rune(-1), 0
+	for _, r := range s {
+		switch r {
+		case vs15, vs16:
+			if prev < 0 || !allowsSelector(prev, r) {
+				return fail(rule, "%s is not part of an emoji variation sequence", codePoint(r))
+			}
+		case zwj, zwnj:
+			switch {
+			case prev < 0:
+				return fail(rule, "%s at the start", codePoint(r))
+			case prev == zwj || prev == zwnj:
+				return fail(rule, "%s right after %s", codePoint(r), codePoint(prev))
+			case i+utf8.RuneLen(r) == len(s):
+				return fail(rule, "%s at the end", codePoint(r))
+			}
+		}
+		prev = r
+		i += utf8.RuneLen(r)
+	}
+	return nil
+}
+
+func checkR5(s string) error {
+	switch {
+	case strings.HasPrefix(s, " "):
+		return fail("R5", "the segment starts with U+0020")
+	case strings.HasSuffix(s, " "):
+		return fail("R5", "the segment ends with U+0020")
+	case strings.HasSuffix(s, "."):
+		return fail("R5", "the segment ends with '.'")
+	}
+	return nil
+}
+
+// reserved are the device names of R6, in upper case.
+var reserved = map[string]bool{
+	"CON": true, "PRN": true, "AUX": true, "NUL": true, "CONIN$": true, "CONOUT$": true,
+	"COM¹": true, "COM²": true, "COM³": true, "LPT¹": true, "LPT²": true, "LPT³": true,
+}
+
+func init() {
+	for d := '0'; d <= '9'; d++ {
+		reserved["COM"+string(d)] = true
+		reserved["LPT"+string(d)] = true
+	}
+}
+
+func checkR6(s string) error {
+	base, _, _ := strings.Cut(s, ".")
+	base = strings.TrimRight(base, " ")
+	if name := asciiUpper(base); reserved[name] {
+		return fail("R6", "%s is a reserved device name", name)
+	}
+	return nil
+}
+
+// asciiUpper upper-cases ASCII letters only.
+func asciiUpper(s string) string {
+	return strings.Map(func(r rune) rune {
+		if r >= 'a' && r <= 'z' {
+			return r - 'a' + 'A'
+		}
+		return r
+	}, s)
+}
+
+// shortNameBase is the base of an 8.3 alias in R6b: it ends in '~' and 1 to
+// 6 ASCII digits. It has no lookahead, which the regexp package lacks.
+var shortNameBase = regexp.MustCompile(`^[^.]*~[0-9]{1,6}$`)
+
+func checkR6b(s string) error {
+	if strings.Count(s, ".") > 1 {
+		return nil
+	}
+	base, ext, _ := strings.Cut(s, ".")
+	if n := utf8.RuneCountInString(base); n < 1 || n > 8 {
+		return nil
+	}
+	if utf8.RuneCountInString(ext) > 3 || !shortNameBase.MatchString(base) {
+		return nil
+	}
+	return fail("R6b", "the segment has the form of an 8.3 alias")
+}
+
+// checkR6c projects the segment with each best-fit table: every non-ASCII
+// code point the table maps to an ASCII byte is replaced by that byte. A
+// projection must not hold '/', '\', ':' or U+0000, and must pass R3, R5, R6
+// and R6b.
+func checkR6c(s string) error {
+	for i := range bestFitTables {
+		t := &bestFitTables[i]
+		p, changed := project(s, t)
+		if !changed {
+			continue
+		}
+		if j := strings.IndexAny(p, "/\\:\x00"); j >= 0 {
+			return fail("R6c", "code page %s maps the segment to one with %s", t.name, codePoint(rune(p[j])))
+		}
+		for _, check := range []func(string) error{checkR3, checkR5, checkR6, checkR6b} {
+			if err := check(p); err != nil {
+				e := err.(*Error)
+				return fail("R6c", "code page %s maps the segment to one that breaks %s: %s", t.name, e.Rule, e.Detail)
+			}
+		}
+	}
+	return nil
+}
+
+func project(s string, t *bestFitTable) (string, bool) {
+	var b strings.Builder
+	changed := false
+	for _, r := range s {
+		if r >= 0x80 {
+			if c, ok := t.lookup(r); ok {
+				b.WriteByte(c)
+				changed = true
+				continue
+			}
+		}
+		b.WriteRune(r)
+	}
+	return b.String(), changed
+}
+
+// CheckTree applies R7 and then R9 to the paths of a head, which have passed
+// CheckPath: no two siblings with the same key, no path that is both a file
+// and a folder, comparing keys, and at most MaxImplicitDirs folders. Paths
+// are numbered from 1 in the messages.
+func CheckTree(paths []string) error {
+	type node struct {
+		name string
+		dir  bool
+		path int // the first path that reached it
+	}
+	// children maps the key of a folder, "" for the root, to its children by
+	// key; the key of a folder joins the keys of its segments with '/'.
+	children := map[string]map[string]node{}
+	for n, path := range paths {
+		segs := strings.Split(path, "/")
+		parent := ""
+		for i, s := range segs {
+			k := Key(s)
+			isDir := i < len(segs)-1
+			kids := children[parent]
+			if kids == nil {
+				kids = map[string]node{}
+				children[parent] = kids
+			}
+			switch old, ok := kids[k]; {
+			case !ok:
+				kids[k] = node{name: s, dir: isDir, path: n + 1}
+			case old.name != s:
+				return fail("R7", "path %d collides with path %d in segment %d", n+1, old.path, i+1)
+			case old.dir != isDir || !isDir:
+				return fail("R7", "path %d makes a file of path %d a folder, or the reverse, in segment %d", n+1, old.path, i+1)
+			}
+			if parent == "" {
+				parent = k
+			} else {
+				parent += "/" + k
+			}
+		}
+	}
+	dirs := map[string]bool{}
+	for _, path := range paths {
+		for i := 0; ; {
+			j := strings.IndexByte(path[i:], '/')
+			if j < 0 {
+				break
+			}
+			i += j
+			dirs[path[:i]] = true
+			i++
+		}
+	}
+	if len(dirs) > MaxImplicitDirs {
+		return fail("R9", "%d folders, more than %d", len(dirs), MaxImplicitDirs)
+	}
+	return nil
+}
+
+// CheckComment checks the comment of a head (spec §29.6).
+func CheckComment(s string) error {
+	return checkText(s, true)
+}
+
+// CheckAuthor checks the declared author of a head (spec §29.6).
+func CheckAuthor(s string) error {
+	if err := checkText(s, false); err != nil {
+		return err
+	}
+	if strings.HasPrefix(s, " ") || strings.HasSuffix(s, " ") {
+		return fail("text", "the declared author starts or ends with U+0020")
+	}
+	return nil
+}
+
+// checkText applies the rules of spec §29.6, code point by code point, and
+// then R4b to each line.
+func checkText(s string, comment bool) error {
+	for _, r := range s {
+		switch {
+		case r == '\t' || r == '\n':
+			if !comment {
+				return fail("text", "control %s in the declared author", codePoint(r))
+			}
+		case r <= 0x1F || (r >= 0x7F && r <= 0x9F):
+			return fail("text", "control %s", codePoint(r))
+		case (r >= 0x202A && r <= 0x202E) || (r >= 0x2066 && r <= 0x2069) || r == 0x061C || r == 0x200E || r == 0x200F:
+			return fail("text", "bidirectional control %s", codePoint(r))
+		case r == 0x2028 || r == 0x2029:
+			return fail("text", "separator %s", codePoint(r))
+		case r == 0xFEFF:
+			return fail("text", "byte order mark %s", codePoint(r))
+		case isNoncharacter(r):
+			return fail("text", "noncharacter %s", codePoint(r))
+		case DefaultIgnorable(r) && !whitelisted(r):
+			return fail("text", "invisible %s", codePoint(r))
+		}
+	}
+	for i, line := range strings.Split(s, "\n") {
+		if err := checkPlacement("text", line); err != nil {
+			e := err.(*Error)
+			e.Detail = fmt.Sprintf("line %d: %s", i+1, e.Detail)
+			return e
+		}
+	}
+	return nil
+}
+
+// isNoncharacter reports the 66 noncharacters: U+FDD0 to U+FDEF, and the last
+// two code points of each plane.
+func isNoncharacter(r rune) bool {
+	return (r >= 0xFDD0 && r <= 0xFDEF) || r&0xFFFE == 0xFFFE
+}
diff --git a/internal/pathrule/tables.go b/internal/pathrule/tables.go
new file mode 100644
index 0000000..aaf316e
--- /dev/null
+++ b/internal/pathrule/tables.go
@@ -0,0 +1,2145 @@
+// Code generated by internal/pathrule/gen from Unicode 18.0.0 and WindowsBestFit. DO NOT EDIT.
+
+package pathrule
+
+// UnicodeVersion is the version of Unicode of these tables, fixed with
+// capsule format 3 (spec §29.5.1).
+const UnicodeVersion = "18.0.0"
+
+// TablesDigest is the SHA-256 of the canonical text of these tables (see
+// Canonical). Another implementation generated from the same files has it too.
+const TablesDigest = "7bb770bac2c81497f520da6b079e6c4fcbcf140e937a2d4203da3ba7b46df2e2"
+
+// Sources are the data files of the tables and their SHA-256 (spec §29.5.1).
+var Sources = []struct{ Path, SHA256 string }{
+	{"unicode/18.0.0/UnicodeData.txt", "0736451de439ae7baf1425136617da495e09ee5afbe6e394374db7009ea08950"},
+	{"unicode/18.0.0/DerivedCoreProperties.txt", "09c928886a178fcafd93c29e4bd59073a058e5a100b716d425cb563ab50f68c9"},
+	{"unicode/18.0.0/CaseFolding.txt", "a004797658a457bec4dc11683e39f69249ea3b595b752dbea6721c4c9f587b0d"},
+	{"unicode/18.0.0/emoji/emoji-variation-sequences.txt", "ff1707564aa1f1b2fcf4ec92d609d4cb26940bc0d4dcf07f5328ad6879e84da3"},
+	{"bestfit/bestfit874.txt", "663f43ca662e037c4534cb16298b560f29ce29c27b49b3589601ec3d97dd89fd"},
+	{"bestfit/bestfit932.txt", "2614cfea35c3c86c41d33198793a84ca44edee3cf0ee0013a61a43fba4ece331"},
+	{"bestfit/bestfit936.txt", "e5070a2d6ad26619f5872ddbe64d3381c11620af5adbb04cda0f0abb1a91fdae"},
+	{"bestfit/bestfit949.txt", "50e13b60ea8fda66a8223ecc85270e0f182303222244e2345d3d57f3e839d20a"},
+	{"bestfit/bestfit950.txt", "cf8c23389a42a226ea707f7ec32c665556d1fc3364db25bd765ce64d54eaee2a"},
+	{"bestfit/bestfit1250.txt", "cef9f171e67b09445bcb3f9ffccdc89418250ff825f1bd2d29a92d2074d7a53b"},
+	{"bestfit/bestfit1251.txt", "59ec85612ff908d9da0e877893c935941e56b13a2882b4fb9c9599be3d1ce4e7"},
+	{"bestfit/bestfit1252.txt", "72ea23c939c5b26fae7aded0207b327e2f3902d7d3c168d7087f5cfc38ee76a9"},
+	{"bestfit/bestfit1253.txt", "ea80c442aff7f09b36da6335f85f8e527f51c146beeb9825ec00d1b6ca99a99e"},
+	{"bestfit/bestfit1254.txt", "3d02512087634dc493b720992b590277736ffb2d5b0b665d69b6b9727e2c361a"},
+	{"bestfit/bestfit1255.txt", "fdd4bdda74f6571d89171b0070ac052cd3714c395dc3d1799bcd5e4a4da6f83a"},
+	{"bestfit/bestfit1256.txt", "745c447ada04a838da8bea406c13f446c7453b6371e8c6c7863a632443d56007"},
+	{"bestfit/bestfit1257.txt", "b8c5d7f3b8c25c3d5625d44dd3d6ee7a06e652ddf77373d050282c1cb7517366"},
+	{"bestfit/bestfit1258.txt", "5d52a9357b7d6b5b5014ed5a51be0ff9809b0c33625793d2a4feaf502e0682f1"},
+	{"bestfit/bestfit1361.txt", "7dcda2d5d2cfc5ddf43757d589a0106e020ef0d9b84de47f08e18297ae0fe1ec"},
+}
+
+// assignedRanges are the assigned code points, as inclusive ranges: lo, hi, ...
+var assignedRanges = []rune{
+	0x0000, 0x0377, 0x037A, 0x037F, 0x0384, 0x038A, 0x038C, 0x038C, 0x038E, 0x03A1, 0x03A3, 0x052F,
+	0x0531, 0x0556, 0x0558, 0x058F, 0x0591, 0x05C9, 0x05D0, 0x05EA, 0x05EF, 0x05F4, 0x0600, 0x070D,
+	0x070F, 0x074A, 0x074D, 0x07B1, 0x07C0, 0x07FA, 0x07FD, 0x082D, 0x0830, 0x083E, 0x0840, 0x085B,
+	0x085E, 0x085E, 0x0860, 0x086A, 0x0870, 0x0891, 0x0897, 0x0983, 0x0985, 0x098C, 0x098F, 0x0990,
+	0x0993, 0x09A8, 0x09AA, 0x09B0, 0x09B2, 0x09B2, 0x09B6, 0x09B9, 0x09BC, 0x09C4, 0x09C7, 0x09C8,
+	0x09CB, 0x09CE, 0x09D7, 0x09D7, 0x09DC, 0x09DD, 0x09DF, 0x09E3, 0x09E6, 0x09FE, 0x0A01, 0x0A03,
+	0x0A05, 0x0A0A, 0x0A0F, 0x0A10, 0x0A13, 0x0A28, 0x0A2A, 0x0A30, 0x0A32, 0x0A33, 0x0A35, 0x0A36,
+	0x0A38, 0x0A39, 0x0A3C, 0x0A3C, 0x0A3E, 0x0A42, 0x0A47, 0x0A48, 0x0A4B, 0x0A4D, 0x0A51, 0x0A51,
+	0x0A59, 0x0A5C, 0x0A5E, 0x0A5E, 0x0A66, 0x0A76, 0x0A81, 0x0A83, 0x0A85, 0x0A8D, 0x0A8F, 0x0A91,
+	0x0A93, 0x0AA8, 0x0AAA, 0x0AB0, 0x0AB2, 0x0AB3, 0x0AB5, 0x0AB9, 0x0ABC, 0x0AC5, 0x0AC7, 0x0AC9,
+	0x0ACB, 0x0ACD, 0x0AD0, 0x0AD0, 0x0AE0, 0x0AE3, 0x0AE6, 0x0AF1, 0x0AF9, 0x0AFF, 0x0B01, 0x0B03,
+	0x0B05, 0x0B0C, 0x0B0F, 0x0B10, 0x0B13, 0x0B28, 0x0B2A, 0x0B30, 0x0B32, 0x0B33, 0x0B35, 0x0B39,
+	0x0B3C, 0x0B44, 0x0B47, 0x0B48, 0x0B4B, 0x0B4D, 0x0B53, 0x0B57, 0x0B5C, 0x0B5D, 0x0B5F, 0x0B63,
+	0x0B66, 0x0B77, 0x0B82, 0x0B83, 0x0B85, 0x0B8A, 0x0B8E, 0x0B90, 0x0B92, 0x0B95, 0x0B99, 0x0B9A,
+	0x0B9C, 0x0B9C, 0x0B9E, 0x0B9F, 0x0BA3, 0x0BA4, 0x0BA8, 0x0BAA, 0x0BAE, 0x0BB9, 0x0BBE, 0x0BC2,
+	0x0BC6, 0x0BC8, 0x0BCA, 0x0BCD, 0x0BD0, 0x0BD0, 0x0BD7, 0x0BD7, 0x0BE6, 0x0BFA, 0x0C00, 0x0C0C,
+	0x0C0E, 0x0C10, 0x0C12, 0x0C28, 0x0C2A, 0x0C39, 0x0C3C, 0x0C44, 0x0C46, 0x0C48, 0x0C4A, 0x0C4D,
+	0x0C55, 0x0C56, 0x0C58, 0x0C5A, 0x0C5C, 0x0C5D, 0x0C60, 0x0C63, 0x0C66, 0x0C6F, 0x0C77, 0x0C8C,
+	0x0C8E, 0x0C90, 0x0C92, 0x0CA8, 0x0CAA, 0x0CB3, 0x0CB5, 0x0CB9, 0x0CBC, 0x0CC4, 0x0CC6, 0x0CC8,
+	0x0CCA, 0x0CCD, 0x0CD5, 0x0CD6, 0x0CDC, 0x0CDE, 0x0CE0, 0x0CE3, 0x0CE6, 0x0CEF, 0x0CF1, 0x0CF3,
+	0x0D00, 0x0D0C, 0x0D0E, 0x0D10, 0x0D12, 0x0D44, 0x0D46, 0x0D48, 0x0D4A, 0x0D4F, 0x0D54, 0x0D63,
+	0x0D66, 0x0D7F, 0x0D81, 0x0D83, 0x0D85, 0x0D96, 0x0D9A, 0x0DB1, 0x0DB3, 0x0DBB, 0x0DBD, 0x0DBD,
+	0x0DC0, 0x0DC6, 0x0DCA, 0x0DCA, 0x0DCF, 0x0DD4, 0x0DD6, 0x0DD6, 0x0DD8, 0x0DDF, 0x0DE6, 0x0DEF,
+	0x0DF2, 0x0DF4, 0x0E01, 0x0E3A, 0x0E3F, 0x0E5B, 0x0E81, 0x0E82, 0x0E84, 0x0E84, 0x0E86, 0x0E8A,
+	0x0E8C, 0x0EA3, 0x0EA5, 0x0EA5, 0x0EA7, 0x0EBD, 0x0EC0, 0x0EC4, 0x0EC6, 0x0EC6, 0x0EC8, 0x0ECE,
+	0x0ED0, 0x0ED9, 0x0EDC, 0x0EDF, 0x0F00, 0x0F47, 0x0F49, 0x0F6C, 0x0F71, 0x0F97, 0x0F99, 0x0FBC,
+	0x0FBE, 0x0FCC, 0x0FCE, 0x0FDA, 0x1000, 0x10C5, 0x10C7, 0x10C7, 0x10CD, 0x10CD, 0x10D0, 0x1248,
+	0x124A, 0x124D, 0x1250, 0x1256, 0x1258, 0x1258, 0x125A, 0x125D, 0x1260, 0x1288, 0x128A, 0x128D,
+	0x1290, 0x12B0, 0x12B2, 0x12B5, 0x12B8, 0x12BE, 0x12C0, 0x12C0, 0x12C2, 0x12C5, 0x12C8, 0x12D6,
+	0x12D8, 0x1310, 0x1312, 0x1315, 0x1318, 0x135A, 0x135D, 0x137C, 0x1380, 0x1399, 0x13A0, 0x13F5,
+	0x13F8, 0x13FD, 0x1400, 0x169C, 0x16A0, 0x16F8, 0x1700, 0x1715, 0x171F, 0x1736, 0x1740, 0x1753,
+	0x1760, 0x176C, 0x176E, 0x1770, 0x1772, 0x1773, 0x1780, 0x17DD, 0x17E0, 0x17E9, 0x17F0, 0x17F9,
+	0x1800, 0x1819, 0x1820, 0x1878, 0x1880, 0x18AA, 0x18B0, 0x18F5, 0x1900, 0x191E, 0x1920, 0x192B,
+	0x1930, 0x193B, 0x1940, 0x1940, 0x1944, 0x196D, 0x1970, 0x1974, 0x1980, 0x19AB, 0x19B0, 0x19C9,
+	0x19D0, 0x19DA, 0x19DE, 0x1A1B, 0x1A1E, 0x1A5E, 0x1A60, 0x1A7C, 0x1A7F, 0x1A89, 0x1A90, 0x1A99,
+	0x1AA0, 0x1AAD, 0x1AB0, 0x1AF0, 0x1B00, 0x1B4C, 0x1B4E, 0x1BF3, 0x1BFC, 0x1C37, 0x1C3B, 0x1C49,
+	0x1C4D, 0x1C8A, 0x1C90, 0x1CBA, 0x1CBD, 0x1CC7, 0x1CD0, 0x1CFA, 0x1D00, 0x1F15, 0x1F18, 0x1F1D,
+	0x1F20, 0x1F45, 0x1F48, 0x1F4D, 0x1F50, 0x1F57, 0x1F59, 0x1F59, 0x1F5B, 0x1F5B, 0x1F5D, 0x1F5D,
+	0x1F5F, 0x1F7D, 0x1F80, 0x1FB4, 0x1FB6, 0x1FC4, 0x1FC6, 0x1FD3, 0x1FD6, 0x1FDB, 0x1FDD, 0x1FEF,
+	0x1FF2, 0x1FF4, 0x1FF6, 0x1FFE, 0x2000, 0x2064, 0x2066, 0x2071, 0x2074, 0x20C4, 0x20D0, 0x20F0,
+	0x2100, 0x218B, 0x2190, 0x2429, 0x2440, 0x244A, 0x2460, 0x2B73, 0x2B76, 0x2CF3, 0x2CF9, 0x2D25,
+	0x2D27, 0x2D27, 0x2D2D, 0x2D2D, 0x2D30, 0x2D67, 0x2D6F, 0x2D70, 0x2D7F, 0x2D96, 0x2DA0, 0x2DA6,
+	0x2DA8, 0x2DAE, 0x2DB0, 0x2DB6, 0x2DB8, 0x2DBE, 0x2DC0, 0x2DC6, 0x2DC8, 0x2DCE, 0x2DD0, 0x2DD6,
+	0x2DD8, 0x2DDE, 0x2DE0, 0x2E5D, 0x2E60, 0x2E63, 0x2E80, 0x2E99, 0x2E9B, 0x2EF3, 0x2F00, 0x2FD5,
+	0x2FF0, 0x303F, 0x3041, 0x3096, 0x3099, 0x30FF, 0x3105, 0x312F, 0x3131, 0x318E, 0x3190, 0x31E5,
+	0x31EF, 0x321E, 0x3220, 0xA48C, 0xA490, 0xA4C6, 0xA4D0, 0xA62B, 0xA640, 0xA6F7, 0xA700, 0xA7DD,
+	0xA7E2, 0xA7E2, 0xA7F1, 0xA82C, 0xA830, 0xA839, 0xA840, 0xA877, 0xA880, 0xA8C5, 0xA8CE, 0xA8D9,
+	0xA8E0, 0xA953, 0xA95F, 0xA97C, 0xA980, 0xA9CD, 0xA9CF, 0xA9D9, 0xA9DE, 0xA9FE, 0xAA00, 0xAA36,
+	0xAA40, 0xAA4D, 0xAA50, 0xAA59, 0xAA5C, 0xAAC2, 0xAADB, 0xAAF6, 0xAB01, 0xAB06, 0xAB09, 0xAB0E,
+	0xAB11, 0xAB16, 0xAB20, 0xAB26, 0xAB28, 0xAB2E, 0xAB30, 0xAB6D, 0xAB70, 0xABED, 0xABF0, 0xABF9,
+	0xAC00, 0xD7A3, 0xD7B0, 0xD7C6, 0xD7CB, 0xD7FB, 0xD800, 0xFA6D, 0xFA70, 0xFAD9, 0xFB00, 0xFB06,
+	0xFB13, 0xFB17, 0xFB1D, 0xFB36, 0xFB38, 0xFB3C, 0xFB3E, 0xFB3E, 0xFB40, 0xFB41, 0xFB43, 0xFB44,
+	0xFB46, 0xFDCF, 0xFDF0, 0xFE19, 0xFE20, 0xFE52, 0xFE54, 0xFE66, 0xFE68, 0xFE6B, 0xFE70, 0xFE74,
+	0xFE76, 0xFEFC, 0xFEFF, 0xFEFF, 0xFF01, 0xFFBE, 0xFFC2, 0xFFC7, 0xFFCA, 0xFFCF, 0xFFD2, 0xFFD7,
+	0xFFDA, 0xFFDC, 0xFFE0, 0xFFE6, 0xFFE8, 0xFFEE, 0xFFF9, 0xFFFD, 0x10000, 0x1000B, 0x1000D, 0x10026,
+	0x10028, 0x1003A, 0x1003C, 0x1003D, 0x1003F, 0x1004D, 0x10050, 0x1005D, 0x10080, 0x100FA, 0x10100, 0x10102,
+	0x10107, 0x10133, 0x10137, 0x1018E, 0x10190, 0x1019C, 0x101A0, 0x101A0, 0x101D0, 0x101FD, 0x10280, 0x1029C,
+	0x102A0, 0x102D0, 0x102E0, 0x102FB, 0x10300, 0x10323, 0x1032D, 0x1034A, 0x10350, 0x1037A, 0x10380, 0x1039D,
+	0x1039F, 0x103C3, 0x103C8, 0x103D5, 0x10400, 0x1049D, 0x104A0, 0x104A9, 0x104B0, 0x104D3, 0x104D8, 0x104FB,
+	0x10500, 0x10527, 0x10530, 0x10563, 0x1056F, 0x1057A, 0x1057C, 0x1058A, 0x1058C, 0x10592, 0x10594, 0x10595,
+	0x10597, 0x105A1, 0x105A3, 0x105B1, 0x105B3, 0x105B9, 0x105BB, 0x105BC, 0x105C0, 0x105F3, 0x10600, 0x10736,
+	0x10740, 0x10755, 0x10760, 0x10767, 0x10780, 0x10785, 0x10787, 0x107B0, 0x107B2, 0x107BF, 0x10800, 0x10805,
+	0x10808, 0x10808, 0x1080A, 0x10835, 0x10837, 0x10838, 0x1083C, 0x1083C, 0x1083F, 0x10855, 0x10857, 0x1089E,
+	0x108A7, 0x108AF, 0x108E0, 0x108F2, 0x108F4, 0x108F5, 0x108FB, 0x1091B, 0x1091F, 0x10939, 0x1093F, 0x10959,
+	0x10980, 0x109B7, 0x109BC, 0x109CF, 0x109D2, 0x10A03, 0x10A05, 0x10A06, 0x10A0C, 0x10A13, 0x10A15, 0x10A17,
+	0x10A19, 0x10A35, 0x10A38, 0x10A3A, 0x10A3F, 0x10A48, 0x10A50, 0x10A58, 0x10A60, 0x10A9F, 0x10AC0, 0x10AE6,
+	0x10AEB, 0x10AF6, 0x10B00, 0x10B35, 0x10B39, 0x10B55, 0x10B58, 0x10B72, 0x10B78, 0x10B91, 0x10B99, 0x10B9C,
+	0x10BA9, 0x10BAF, 0x10C00, 0x10C48, 0x10C80, 0x10CB2, 0x10CC0, 0x10CF2, 0x10CFA, 0x10D27, 0x10D30, 0x10D39,
+	0x10D40, 0x10D65, 0x10D69, 0x10D85, 0x10D8E, 0x10D8F, 0x10E60, 0x10E7E, 0x10E80, 0x10EA9, 0x10EAB, 0x10EAD,
+	0x10EB0, 0x10EB1, 0x10EC2, 0x10EC7, 0x10EC9, 0x10EEE, 0x10EF0, 0x10F27, 0x10F30, 0x10F59, 0x10F70, 0x10F89,
+	0x10FB0, 0x10FCB, 0x10FE0, 0x10FF6, 0x11000, 0x1104D, 0x11052, 0x11075, 0x1107F, 0x110C2, 0x110CD, 0x110CD,
+	0x110D0, 0x110E8, 0x110F0, 0x110F9, 0x11100, 0x11134, 0x11136, 0x11147, 0x11150, 0x11176, 0x11180, 0x111DF,
+	0x111E1, 0x111F4, 0x11200, 0x11211, 0x11213, 0x11241, 0x11280, 0x11286, 0x11288, 0x11288, 0x1128A, 0x1128D,
+	0x1128F, 0x1129D, 0x1129F, 0x112A9, 0x112B0, 0x112EA, 0x112F0, 0x112F9, 0x11300, 0x11303, 0x11305, 0x1130C,
+	0x1130F, 0x11310, 0x11313, 0x11328, 0x1132A, 0x11330, 0x11332, 0x11333, 0x11335, 0x11339, 0x1133B, 0x11344,
+	0x11347, 0x11348, 0x1134B, 0x1134D, 0x11350, 0x11350, 0x11357, 0x11357, 0x1135D, 0x11363, 0x11366, 0x1136C,
+	0x11370, 0x11374, 0x11380, 0x11389, 0x1138B, 0x1138B, 0x1138E, 0x1138E, 0x11390, 0x113B5, 0x113B7, 0x113C0,
+	0x113C2, 0x113C2, 0x113C5, 0x113C5, 0x113C7, 0x113CA, 0x113CC, 0x113D5, 0x113D7, 0x113D8, 0x113E1, 0x113E2,
+	0x11400, 0x1145B, 0x1145D, 0x11461, 0x11480, 0x114C7, 0x114D0, 0x114D9, 0x11580, 0x115B5, 0x115B8, 0x115DD,
+	0x11600, 0x11644, 0x11650, 0x11659, 0x11660, 0x1166C, 0x11680, 0x116B9, 0x116C0, 0x116C9, 0x116D0, 0x116E3,
+	0x11700, 0x1171A, 0x1171D, 0x1172B, 0x11730, 0x11746, 0x11800, 0x1183B, 0x118A0, 0x118F2, 0x118FF, 0x11906,
+	0x11909, 0x11909, 0x1190C, 0x11913, 0x11915, 0x11916, 0x11918, 0x11935, 0x11937, 0x11938, 0x1193B, 0x11946,
+	0x11950, 0x11959, 0x119A0, 0x119A7, 0x119AA, 0x119D7, 0x119DA, 0x119E4, 0x11A00, 0x11A47, 0x11A50, 0x11AA2,
+	0x11AB0, 0x11AF8, 0x11B00, 0x11B0A, 0x11B60, 0x11B67, 0x11BC0, 0x11BE1, 0x11BF0, 0x11BF9, 0x11C00, 0x11C08,
+	0x11C0A, 0x11C36, 0x11C38, 0x11C45, 0x11C50, 0x11C6C, 0x11C70, 0x11C8F, 0x11C92, 0x11CA7, 0x11CA9, 0x11CB6,
+	0x11D00, 0x11D06, 0x11D08, 0x11D09, 0x11D0B, 0x11D36, 0x11D3A, 0x11D3A, 0x11D3C, 0x11D3D, 0x11D3F, 0x11D47,
+	0x11D50, 0x11D59, 0x11D60, 0x11D65, 0x11D67, 0x11D68, 0x11D6A, 0x11D8E, 0x11D90, 0x11D91, 0x11D93, 0x11D98,
+	0x11DA0, 0x11DA9, 0x11DB0, 0x11DDB, 0x11DE0, 0x11DE9, 0x11DF0, 0x11DF1, 0x11EE0, 0x11EF8, 0x11F00, 0x11F10,
+	0x11F12, 0x11F3A, 0x11F3E, 0x11F5A, 0x11FB0, 0x11FB0, 0x11FC0, 0x11FF1, 0x11FFF, 0x12399, 0x12400, 0x12543,
+	0x12550, 0x12686, 0x12F90, 0x12FF2, 0x13000, 0x13455, 0x13460, 0x143FA, 0x14400, 0x14646, 0x16100, 0x16139,
+	0x16800, 0x16A38, 0x16A40, 0x16A5E, 0x16A60, 0x16A69, 0x16A6E, 0x16ABE, 0x16AC0, 0x16AC9, 0x16AD0, 0x16AED,
+	0x16AF0, 0x16AF5, 0x16B00, 0x16B45, 0x16B50, 0x16B59, 0x16B5B, 0x16B61, 0x16B63, 0x16B77, 0x16B7D, 0x16B8F,
+	0x16D40, 0x16D79, 0x16E40, 0x16E9A, 0x16EA0, 0x16EB8, 0x16EBB, 0x16ED3, 0x16F00, 0x16F4A, 0x16F4F, 0x16F87,
+	0x16F8F, 0x16F9F, 0x16FE0, 0x16FE4, 0x16FF0, 0x16FF6, 0x17000, 0x18CDA, 0x18CFF, 0x18D20, 0x18D80, 0x18DF2,
+	0x18E00, 0x19191, 0x191A0, 0x191D2, 0x1AFF0, 0x1AFF3, 0x1AFF5, 0x1AFFB, 0x1AFFD, 0x1AFFE, 0x1B000, 0x1B128,
+	0x1B132, 0x1B132, 0x1B150, 0x1B152, 0x1B155, 0x1B155, 0x1B164, 0x1B168, 0x1B170, 0x1B2FB, 0x1BC00, 0x1BC6A,
+	0x1BC70, 0x1BC7C, 0x1BC80, 0x1BC88, 0x1BC90, 0x1BC99, 0x1BC9C, 0x1BCA3, 0x1CC00, 0x1CCFC, 0x1CD00, 0x1CEB3,
+	0x1CEBA, 0x1CED0, 0x1CED2, 0x1CED4, 0x1CEDD, 0x1CEFD, 0x1CF00, 0x1CF2D, 0x1CF30, 0x1CF46, 0x1CF50, 0x1CFC3,
+	0x1D000, 0x1D0F5, 0x1D100, 0x1D245, 0x1D250, 0x1D281, 0x1D2C0, 0x1D2D3, 0x1D2E0, 0x1D2F3, 0x1D300, 0x1D356,
+	0x1D360, 0x1D378, 0x1D400, 0x1D454, 0x1D456, 0x1D49C, 0x1D49E, 0x1D49F, 0x1D4A2, 0x1D4A2, 0x1D4A5, 0x1D4A6,
+	0x1D4A9, 0x1D4AC, 0x1D4AE, 0x1D4B9, 0x1D4BB, 0x1D4BB, 0x1D4BD, 0x1D4C3, 0x1D4C5, 0x1D505, 0x1D507, 0x1D50A,
+	0x1D50D, 0x1D514, 0x1D516, 0x1D51C, 0x1D51E, 0x1D539, 0x1D53B, 0x1D53E, 0x1D540, 0x1D544, 0x1D546, 0x1D546,
+	0x1D54A, 0x1D550, 0x1D552, 0x1D6A6, 0x1D6A8, 0x1D7CB, 0x1D7CE, 0x1DA8B, 0x1DA9B, 0x1DA9F, 0x1DAA1, 0x1DAAF,
+	0x1DB00, 0x1DB1C, 0x1DF00, 0x1DF81, 0x1DF90, 0x1DF96, 0x1DFCD, 0x1E006, 0x1E008, 0x1E018, 0x1E01B, 0x1E021,
+	0x1E023, 0x1E024, 0x1E026, 0x1E02A, 0x1E030, 0x1E06D, 0x1E08F, 0x1E08F, 0x1E100, 0x1E12C, 0x1E130, 0x1E13D,
+	0x1E140, 0x1E149, 0x1E14E, 0x1E14F, 0x1E290, 0x1E2AE, 0x1E2C0, 0x1E2F9, 0x1E2FF, 0x1E2FF, 0x1E4D0, 0x1E4F9,
+	0x1E5D0, 0x1E5FA, 0x1E5FF, 0x1E5FF, 0x1E6C0, 0x1E6DE, 0x1E6E0, 0x1E6F5, 0x1E6FE, 0x1E6FF, 0x1E7E0, 0x1E7E6,
+	0x1E7E8, 0x1E7EB, 0x1E7ED, 0x1E7EE, 0x1E7F0, 0x1E7FE, 0x1E800, 0x1E8C4, 0x1E8C7, 0x1E8D6, 0x1E900, 0x1E94B,
+	0x1E950, 0x1E959, 0x1E95E, 0x1E95F, 0x1EC71, 0x1ECB4, 0x1ED01, 0x1ED3D, 0x1EE00, 0x1EE03, 0x1EE05, 0x1EE1F,
+	0x1EE21, 0x1EE22, 0x1EE24, 0x1EE24, 0x1EE27, 0x1EE27, 0x1EE29, 0x1EE32, 0x1EE34, 0x1EE37, 0x1EE39, 0x1EE39,
+	0x1EE3B, 0x1EE3B, 0x1EE42, 0x1EE42, 0x1EE47, 0x1EE47, 0x1EE49, 0x1EE49, 0x1EE4B, 0x1EE4B, 0x1EE4D, 0x1EE4F,
+	0x1EE51, 0x1EE52, 0x1EE54, 0x1EE54, 0x1EE57, 0x1EE57, 0x1EE59, 0x1EE59, 0x1EE5B, 0x1EE5B, 0x1EE5D, 0x1EE5D,
+	0x1EE5F, 0x1EE5F, 0x1EE61, 0x1EE62, 0x1EE64, 0x1EE64, 0x1EE67, 0x1EE6A, 0x1EE6C, 0x1EE72, 0x1EE74, 0x1EE77,
+	0x1EE79, 0x1EE7C, 0x1EE7E, 0x1EE7E, 0x1EE80, 0x1EE89, 0x1EE8B, 0x1EE9B, 0x1EEA1, 0x1EEA3, 0x1EEA5, 0x1EEA9,
+	0x1EEAB, 0x1EEBB, 0x1EEF0, 0x1EEF1, 0x1F000, 0x1F02B, 0x1F030, 0x1F093, 0x1F0A0, 0x1F0AE, 0x1F0B1, 0x1F0BF,
+	0x1F0C1, 0x1F0CF, 0x1F0D1, 0x1F0F5, 0x1F100, 0x1F1AE, 0x1F1E6, 0x1F202, 0x1F210, 0x1F23B, 0x1F240, 0x1F248,
+	0x1F250, 0x1F251, 0x1F260, 0x1F265, 0x1F300, 0x1F6D9, 0x1F6DC, 0x1F6EC, 0x1F6F0, 0x1F6FC, 0x1F700, 0x1F7DB,
+	0x1F7E0, 0x1F7EB, 0x1F7F0, 0x1F80B, 0x1F810, 0x1F847, 0x1F850, 0x1F859, 0x1F860, 0x1F887, 0x1F890, 0x1F8AD,
+	0x1F8B0, 0x1F8BB, 0x1F8C0, 0x1F8C1, 0x1F8D0, 0x1F8D8, 0x1F900, 0x1FA57, 0x1FA60, 0x1FA6D, 0x1FA70, 0x1FA7C,
+	0x1FA80, 0x1FAC6, 0x1FAC8, 0x1FAC8, 0x1FACC, 0x1FADD, 0x1FADF, 0x1FAEB, 0x1FAEF, 0x1FAFA, 0x1FB00, 0x1FB92,
+	0x1FB94, 0x1FBFA, 0x20000, 0x2A6DF, 0x2A700, 0x2B81E, 0x2B820, 0x2CEAD, 0x2CEB0, 0x2EBE0, 0x2EBF0, 0x2EE5D,
+	0x2F800, 0x2FA1D, 0x30000, 0x3134A, 0x31350, 0x33479, 0x3D000, 0x3FC3F, 0xE0001, 0xE0001, 0xE0020, 0xE007F,
+	0xE0100, 0xE01EF, 0xF0000, 0xFFFFD, 0x100000, 0x10FFFD,
+}
+
+// ignorableRanges are Default_Ignorable_Code_Point, as inclusive ranges.
+var ignorableRanges = []rune{
+	0x00AD, 0x00AD, 0x034F, 0x034F, 0x061C, 0x061C, 0x115F, 0x1160, 0x17B4, 0x17B5, 0x180B, 0x180F,
+	0x200B, 0x200F, 0x202A, 0x202E, 0x2060, 0x206F, 0x3164, 0x3164, 0xFE00, 0xFE0F, 0xFEFF, 0xFEFF,
+	0xFFA0, 0xFFA0, 0xFFF0, 0xFFF8, 0x1BCA0, 0x1BCA3, 0x1D173, 0x1D17A, 0xE0000, 0xE0FFF,
+}
+
+// cccTable holds each code point with a non-zero canonical combining class,
+// as code point << 8 | class, sorted.
+var cccTable = []uint32{
+	0x0300E6, 0x0301E6, 0x0302E6, 0x0303E6, 0x0304E6, 0x0305E6, 0x0306E6, 0x0307E6,
+	0x0308E6, 0x0309E6, 0x030AE6, 0x030BE6, 0x030CE6, 0x030DE6, 0x030EE6, 0x030FE6,
+	0x0310E6, 0x0311E6, 0x0312E6, 0x0313E6, 0x0314E6, 0x0315E8, 0x0316DC, 0x0317DC,
+	0x0318DC, 0x0319DC, 0x031AE8, 0x031BD8, 0x031CDC, 0x031DDC, 0x031EDC, 0x031FDC,
+	0x0320DC, 0x0321CA, 0x0322CA, 0x0323DC, 0x0324DC, 0x0325DC, 0x0326DC, 0x0327CA,
+	0x0328CA, 0x0329DC, 0x032ADC, 0x032BDC, 0x032CDC, 0x032DDC, 0x032EDC, 0x032FDC,
+	0x0330DC, 0x0331DC, 0x0332DC, 0x0333DC, 0x033401, 0x033501, 0x033601, 0x033701,
+	0x033801, 0x0339DC, 0x033ADC, 0x033BDC, 0x033CDC, 0x033DE6, 0x033EE6, 0x033FE6,
+	0x0340E6, 0x0341E6, 0x0342E6, 0x0343E6, 0x0344E6, 0x0345F0, 0x0346E6, 0x0347DC,
+	0x0348DC, 0x0349DC, 0x034AE6, 0x034BE6, 0x034CE6, 0x034DDC, 0x034EDC, 0x0350E6,
+	0x0351E6, 0x0352E6, 0x0353DC, 0x0354DC, 0x0355DC, 0x0356DC, 0x0357E6, 0x0358E8,
+	0x0359DC, 0x035ADC, 0x035BE6, 0x035CE9, 0x035DEA, 0x035EEA, 0x035FE9, 0x0360EA,
+	0x0361EA, 0x0362E9, 0x0363E6, 0x0364E6, 0x0365E6, 0x0366E6, 0x0367E6, 0x0368E6,
+	0x0369E6, 0x036AE6, 0x036BE6, 0x036CE6, 0x036DE6, 0x036EE6, 0x036FE6, 0x0483E6,
+	0x0484E6, 0x0485E6, 0x0486E6, 0x0487E6, 0x0591DC, 0x0592E6, 0x0593E6, 0x0594E6,
+	0x0595E6, 0x0596DC, 0x0597E6, 0x0598E6, 0x0599E6, 0x059ADE, 0x059BDC, 0x059CE6,
+	0x059DE6, 0x059EE6, 0x059FE6, 0x05A0E6, 0x05A1E6, 0x05A2DC, 0x05A3DC, 0x05A4DC,
+	0x05A5DC, 0x05A6DC, 0x05A7DC, 0x05A8E6, 0x05A9E6, 0x05AADC, 0x05ABE6, 0x05ACE6,
+	0x05ADDE, 0x05AEE4, 0x05AFE6, 0x05B00A, 0x05B10B, 0x05B20C, 0x05B30D, 0x05B40E,
+	0x05B50F, 0x05B610, 0x05B711, 0x05B812, 0x05B913, 0x05BA13, 0x05BB14, 0x05BC15,
+	0x05BD16, 0x05BF17, 0x05C118, 0x05C219, 0x05C4E6, 0x05C5DC, 0x05C712, 0x05C80A,
+	0x05C915, 0x0610E6, 0x0611E6, 0x0612E6, 0x0613E6, 0x0614E6, 0x0615E6, 0x0616E6,
+	0x0617E6, 0x06181E, 0x06191F, 0x061A20, 0x064B1B, 0x064C1C, 0x064D1D, 0x064E1E,
+	0x064F1F, 0x065020, 0x065121, 0x065222, 0x0653E6, 0x0654E6, 0x0655DC, 0x0656DC,
+	0x0657E6, 0x0658E6, 0x0659E6, 0x065AE6, 0x065BE6, 0x065CDC, 0x065DE6, 0x065EE6,
+	0x065FDC, 0x067023, 0x06D6E6, 0x06D7E6, 0x06D8E6, 0x06D9E6, 0x06DAE6, 0x06DBE6,
+	0x06DCE6, 0x06DFE6, 0x06E0E6, 0x06E1E6, 0x06E2E6, 0x06E3DC, 0x06E4E6, 0x06E7E6,
+	0x06E8E6, 0x06EADC, 0x06EBE6, 0x06ECE6, 0x06EDDC, 0x071124, 0x0730E6, 0x0731DC,
+	0x0732E6, 0x0733E6, 0x0734DC, 0x0735E6, 0x0736E6, 0x0737DC, 0x0738DC, 0x0739DC,
+	0x073AE6, 0x073BDC, 0x073CDC, 0x073DE6, 0x073EDC, 0x073FE6, 0x0740E6, 0x0741E6,
+	0x0742DC, 0x0743E6, 0x0744DC, 0x0745E6, 0x0746DC, 0x0747E6, 0x0748DC, 0x0749E6,
+	0x074AE6, 0x07EBE6, 0x07ECE6, 0x07EDE6, 0x07EEE6, 0x07EFE6, 0x07F0E6, 0x07F1E6,
+	0x07F2DC, 0x07F3E6, 0x07FDDC, 0x0816E6, 0x0817E6, 0x0818E6, 0x0819E6, 0x081BE6,
+	0x081CE6, 0x081DE6, 0x081EE6, 0x081FE6, 0x0820E6, 0x0821E6, 0x0822E6, 0x0823E6,
+	0x0825E6, 0x0826E6, 0x0827E6, 0x0829E6, 0x082AE6, 0x082BE6, 0x082CE6, 0x082DE6,
+	0x0859DC, 0x085ADC, 0x085BDC, 0x0897E6, 0x0898E6, 0x0899DC, 0x089ADC, 0x089BDC,
+	0x089CE6, 0x089DE6, 0x089EE6, 0x089FE6, 0x08CAE6, 0x08CBE6, 0x08CCE6, 0x08CDE6,
+	0x08CEE6, 0x08CFDC, 0x08D0DC, 0x08D1DC, 0x08D2DC, 0x08D3DC, 0x08D4E6, 0x08D5E6,
+	0x08D6E6, 0x08D7E6, 0x08D8E6, 0x08D9E6, 0x08DAE6, 0x08DBE6, 0x08DCE6, 0x08DDE6,
+	0x08DEE6, 0x08DFE6, 0x08E0E6, 0x08E1E6, 0x08E3DC, 0x08E4E6, 0x08E5E6, 0x08E6DC,
+	0x08E7E6, 0x08E8E6, 0x08E9DC, 0x08EAE6, 0x08EBE6, 0x08ECE6, 0x08EDDC, 0x08EEDC,
+	0x08EFDC, 0x08F01B, 0x08F11C, 0x08F21D, 0x08F3E6, 0x08F4E6, 0x08F5E6, 0x08F6DC,
+	0x08F7E6, 0x08F8E6, 0x08F9DC, 0x08FADC, 0x08FBE6, 0x08FCE6, 0x08FDE6, 0x08FEE6,
+	0x08FFE6, 0x093C07, 0x094D09, 0x0951E6, 0x0952DC, 0x0953E6, 0x0954E6, 0x09BC07,
+	0x09CD09, 0x09FEE6, 0x0A3C07, 0x0A4D09, 0x0ABC07, 0x0ACD09, 0x0B3C07, 0x0B4D09,
+	0x0BCD09, 0x0C3C07, 0x0C4D09, 0x0C5554, 0x0C565B, 0x0CBC07, 0x0CCD09, 0x0D3B09,
+	0x0D3C09, 0x0D4D09, 0x0DCA09, 0x0E3867, 0x0E3967, 0x0E3A09, 0x0E486B, 0x0E496B,
+	0x0E4A6B, 0x0E4B6B, 0x0EB876, 0x0EB976, 0x0EBA09, 0x0EC87A, 0x0EC97A, 0x0ECA7A,
+	0x0ECB7A, 0x0F18DC, 0x0F19DC, 0x0F35DC, 0x0F37DC, 0x0F39D8, 0x0F7181, 0x0F7282,
+	0x0F7484, 0x0F7A82, 0x0F7B82, 0x0F7C82, 0x0F7D82, 0x0F8082, 0x0F82E6, 0x0F83E6,
+	0x0F8409, 0x0F86E6, 0x0F87E6, 0x0FC6DC, 0x103707, 0x103909, 0x103A09, 0x108DDC,
+	0x135DE6, 0x135EE6, 0x135FE6, 0x171409, 0x171509, 0x173409, 0x17D209, 0x17DDE6,
+	0x18A9E4, 0x1939DE, 0x193AE6, 0x193BDC, 0x1A17E6, 0x1A18DC, 0x1A6009, 0x1A75E6,
+	0x1A76E6, 0x1A77E6, 0x1A78E6, 0x1A79E6, 0x1A7AE6, 0x1A7BE6, 0x1A7CE6, 0x1A7FDC,
+	0x1AB0E6, 0x1AB1E6, 0x1AB2E6, 0x1AB3E6, 0x1AB4E6, 0x1AB5DC, 0x1AB6DC, 0x1AB7DC,
+	0x1AB8DC, 0x1AB9DC, 0x1ABADC, 0x1ABBE6, 0x1ABCE6, 0x1ABDDC, 0x1ABFDC, 0x1AC0DC,
+	0x1AC1E6, 0x1AC2E6, 0x1AC3DC, 0x1AC4DC, 0x1AC5E6, 0x1AC6E6, 0x1AC7E6, 0x1AC8E6,
+	0x1AC9E6, 0x1ACADC, 0x1ACBE6, 0x1ACCE6, 0x1ACDE6, 0x1ACEE6, 0x1ACFE6, 0x1AD0E6,
+	0x1AD1E6, 0x1AD2E6, 0x1AD3E6, 0x1AD4E6, 0x1AD5E6, 0x1AD6E6, 0x1AD7E6, 0x1AD8E6,
+	0x1AD9E6, 0x1ADAE6, 0x1ADBE6, 0x1ADCE6, 0x1ADDDC, 0x1ADEE6, 0x1ADFE6, 0x1AE0E6,
+	0x1AE1E6, 0x1AE2E6, 0x1AE3E6, 0x1AE4E6, 0x1AE5E6, 0x1AE6DC, 0x1AE7E6, 0x1AE8E6,
+	0x1AE9E6, 0x1AEAE6, 0x1AEBEA, 0x1AECE6, 0x1AEDE6, 0x1AEEDC, 0x1AEFDC, 0x1AF0E6,
+	0x1B3407, 0x1B4409, 0x1B6BE6, 0x1B6CDC, 0x1B6DE6, 0x1B6EE6, 0x1B6FE6, 0x1B70E6,
+	0x1B71E6, 0x1B72E6, 0x1B73E6, 0x1BAA09, 0x1BAB09, 0x1BE607, 0x1BF209, 0x1BF309,
+	0x1C3707, 0x1CD0E6, 0x1CD1E6, 0x1CD2E6, 0x1CD401, 0x1CD5DC, 0x1CD6DC, 0x1CD7DC,
+	0x1CD8DC, 0x1CD9DC, 0x1CDAE6, 0x1CDBE6, 0x1CDCDC, 0x1CDDDC, 0x1CDEDC, 0x1CDFDC,
+	0x1CE0E6, 0x1CE201, 0x1CE301, 0x1CE401, 0x1CE501, 0x1CE601, 0x1CE701, 0x1CE801,
+	0x1CEDDC, 0x1CF4E6, 0x1CF8E6, 0x1CF9E6, 0x1DC0E6, 0x1DC1E6, 0x1DC2DC, 0x1DC3E6,
+	0x1DC4E6, 0x1DC5E6, 0x1DC6E6, 0x1DC7E6, 0x1DC8E6, 0x1DC9E6, 0x1DCADC, 0x1DCBE6,
+	0x1DCCE6, 0x1DCDEA, 0x1DCED6, 0x1DCFDC, 0x1DD0CA, 0x1DD1E6, 0x1DD2E6, 0x1DD3E6,
+	0x1DD4E6, 0x1DD5E6, 0x1DD6E6, 0x1DD7E6, 0x1DD8E6, 0x1DD9E6, 0x1DDAE6, 0x1DDBE6,
+	0x1DDCE6, 0x1DDDE6, 0x1DDEE6, 0x1DDFE6, 0x1DE0E6, 0x1DE1E6, 0x1DE2E6, 0x1DE3E6,
+	0x1DE4E6, 0x1DE5E6, 0x1DE6E6, 0x1DE7E6, 0x1DE8E6, 0x1DE9E6, 0x1DEAE6, 0x1DEBE6,
+	0x1DECE6, 0x1DEDE6, 0x1DEEE6, 0x1DEFE6, 0x1DF0E6, 0x1DF1E6, 0x1DF2E6, 0x1DF3E6,
+	0x1DF4E6, 0x1DF5E6, 0x1DF6E8, 0x1DF7E4, 0x1DF8E4, 0x1DF9DC, 0x1DFADA, 0x1DFBE6,
+	0x1DFCE9, 0x1DFDDC, 0x1DFEE6, 0x1DFFDC, 0x20D0E6, 0x20D1E6, 0x20D201, 0x20D301,
+	0x20D4E6, 0x20D5E6, 0x20D6E6, 0x20D7E6, 0x20D801, 0x20D901, 0x20DA01, 0x20DBE6,
+	0x20DCE6, 0x20E1E6, 0x20E501, 0x20E601, 0x20E7E6, 0x20E8DC, 0x20E9E6, 0x20EA01,
+	0x20EB01, 0x20ECDC, 0x20EDDC, 0x20EEDC, 0x20EFDC, 0x20F0E6, 0x2CEFE6, 0x2CF0E6,
+	0x2CF1E6, 0x2D7F09, 0x2DE0E6, 0x2DE1E6, 0x2DE2E6, 0x2DE3E6, 0x2DE4E6, 0x2DE5E6,
+	0x2DE6E6, 0x2DE7E6, 0x2DE8E6, 0x2DE9E6, 0x2DEAE6, 0x2DEBE6, 0x2DECE6, 0x2DEDE6,
+	0x2DEEE6, 0x2DEFE6, 0x2DF0E6, 0x2DF1E6, 0x2DF2E6, 0x2DF3E6, 0x2DF4E6, 0x2DF5E6,
+	0x2DF6E6, 0x2DF7E6, 0x2DF8E6, 0x2DF9E6, 0x2DFAE6, 0x2DFBE6, 0x2DFCE6, 0x2DFDE6,
+	0x2DFEE6, 0x2DFFE6, 0x302ADA, 0x302BE4, 0x302CE8, 0x302DDE, 0x302EE0, 0x302FE0,
+	0x309908, 0x309A08, 0xA66FE6, 0xA674E6, 0xA675E6, 0xA676E6, 0xA677E6, 0xA678E6,
+	0xA679E6, 0xA67AE6, 0xA67BE6, 0xA67CE6, 0xA67DE6, 0xA69EE6, 0xA69FE6, 0xA6F0E6,
+	0xA6F1E6, 0xA80609, 0xA82C09, 0xA8C409, 0xA8E0E6, 0xA8E1E6, 0xA8E2E6, 0xA8E3E6,
+	0xA8E4E6, 0xA8E5E6, 0xA8E6E6, 0xA8E7E6, 0xA8E8E6, 0xA8E9E6, 0xA8EAE6, 0xA8EBE6,
+	0xA8ECE6, 0xA8EDE6, 0xA8EEE6, 0xA8EFE6, 0xA8F0E6, 0xA8F1E6, 0xA92BDC, 0xA92CDC,
+	0xA92DDC, 0xA95309, 0xA9B307, 0xA9C009, 0xAAB0E6, 0xAAB2E6, 0xAAB3E6, 0xAAB4DC,
+	0xAAB7E6, 0xAAB8E6, 0xAABEE6, 0xAABFE6, 0xAAC1E6, 0xAAF609, 0xABED09, 0xFB1E1A,
+	0xFE20E6, 0xFE21E6, 0xFE22E6, 0xFE23E6, 0xFE24E6, 0xFE25E6, 0xFE26E6, 0xFE27DC,
+	0xFE28DC, 0xFE29DC, 0xFE2ADC, 0xFE2BDC, 0xFE2CDC, 0xFE2DDC, 0xFE2EE6, 0xFE2FE6,
+	0x101FDDC, 0x102E0DC, 0x10376E6, 0x10377E6, 0x10378E6, 0x10379E6, 0x1037AE6, 0x10A0DDC,
+	0x10A0FE6, 0x10A38E6, 0x10A3901, 0x10A3ADC, 0x10A3F09, 0x10AE5E6, 0x10AE6DC, 0x10D24E6,
+	0x10D25E6, 0x10D26E6, 0x10D27E6, 0x10D69E6, 0x10D6AE6, 0x10D6BE6, 0x10D6CE6, 0x10D6DE6,
+	0x10EABE6, 0x10EACE6, 0x10ECBE6, 0x10ECCDC, 0x10ECDDC, 0x10ECEE6, 0x10ECFE6, 0x10EF0DC,
+	0x10EF1DC, 0x10EF2DC, 0x10EF3E6, 0x10EF4DC, 0x10EF5E6, 0x10EF6DC, 0x10EF7E6, 0x10EF8E6,
+	0x10EF9E6, 0x10EFADC, 0x10EFBDC, 0x10EFDDC, 0x10EFEDC, 0x10EFFDC, 0x10F46DC, 0x10F47DC,
+	0x10F48E6, 0x10F49E6, 0x10F4AE6, 0x10F4BDC, 0x10F4CE6, 0x10F4DDC, 0x10F4EDC, 0x10F4FDC,
+	0x10F50DC, 0x10F82E6, 0x10F83DC, 0x10F84E6, 0x10F85DC, 0x1104609, 0x1107009, 0x1107F09,
+	0x110B909, 0x110BA07, 0x11100E6, 0x11101E6, 0x11102E6, 0x1113309, 0x1113409, 0x1117307,
+	0x111C009, 0x111CA07, 0x1123509, 0x1123607, 0x112E907, 0x112EA09, 0x1133B07, 0x1133C07,
+	0x1134D09, 0x11366E6, 0x11367E6, 0x11368E6, 0x11369E6, 0x1136AE6, 0x1136BE6, 0x1136CE6,
+	0x11370E6, 0x11371E6, 0x11372E6, 0x11373E6, 0x11374E6, 0x113CE09, 0x113CF09, 0x113D009,
+	0x1144209, 0x1144607, 0x1145EE6, 0x114C209, 0x114C307, 0x115BF09, 0x115C007, 0x1163F09,
+	0x116B609, 0x116B707, 0x1172B09, 0x1183909, 0x1183A07, 0x1193D09, 0x1193E09, 0x1194307,
+	0x119E009, 0x11A3409, 0x11A4709, 0x11A9909, 0x11C3F09, 0x11D4207, 0x11D4409, 0x11D4509,
+	0x11D9709, 0x11F4109, 0x11F4209, 0x1612F09, 0x16AF001, 0x16AF101, 0x16AF201, 0x16AF301,
+	0x16AF401, 0x16B30E6, 0x16B31E6, 0x16B32E6, 0x16B33E6, 0x16B34E6, 0x16B35E6, 0x16B36E6,
+	0x16FF006, 0x16FF106, 0x1BC9E01, 0x1D127DC, 0x1D128DC, 0x1D165D8, 0x1D166D8, 0x1D16701,
+	0x1D16801, 0x1D16901, 0x1D16DE2, 0x1D16ED8, 0x1D16FD8, 0x1D170D8, 0x1D171D8, 0x1D172D8,
+	0x1D17BDC, 0x1D17CDC, 0x1D17DDC, 0x1D17EDC, 0x1D17FDC, 0x1D180DC, 0x1D181DC, 0x1D182DC,
+	0x1D185E6, 0x1D186E6, 0x1D187E6, 0x1D188E6, 0x1D189E6, 0x1D18ADC, 0x1D18BDC, 0x1D1AAE6,
+	0x1D1ABE6, 0x1D1ACE6, 0x1D1ADE6, 0x1D242E6, 0x1D243E6, 0x1D244E6, 0x1D250D8, 0x1D251D8,
+	0x1D252D8, 0x1D25B01, 0x1D25C01, 0x1D25FD8, 0x1D280D8, 0x1D281D8, 0x1E000E6, 0x1E001E6,
+	0x1E002E6, 0x1E003E6, 0x1E004E6, 0x1E005E6, 0x1E006E6, 0x1E008E6, 0x1E009E6, 0x1E00AE6,
+	0x1E00BE6, 0x1E00CE6, 0x1E00DE6, 0x1E00EE6, 0x1E00FE6, 0x1E010E6, 0x1E011E6, 0x1E012E6,
+	0x1E013E6, 0x1E014E6, 0x1E015E6, 0x1E016E6, 0x1E017E6, 0x1E018E6, 0x1E01BE6, 0x1E01CE6,
+	0x1E01DE6, 0x1E01EE6, 0x1E01FE6, 0x1E020E6, 0x1E021E6, 0x1E023E6, 0x1E024E6, 0x1E026E6,
+	0x1E027E6, 0x1E028E6, 0x1E029E6, 0x1E02AE6, 0x1E08FE6, 0x1E130E6, 0x1E131E6, 0x1E132E6,
+	0x1E133E6, 0x1E134E6, 0x1E135E6, 0x1E136E6, 0x1E2AEE6, 0x1E2ECE6, 0x1E2EDE6, 0x1E2EEE6,
+	0x1E2EFE6, 0x1E4ECE8, 0x1E4EDE8, 0x1E4EEDC, 0x1E4EFE6, 0x1E5EEE6, 0x1E5EFDC, 0x1E6E3E6,
+	0x1E6E6E6, 0x1E6EEE6, 0x1E6EFE6, 0x1E6F5E6, 0x1E8D0DC, 0x1E8D1DC, 0x1E8D2DC, 0x1E8D3DC,
+	0x1E8D4DC, 0x1E8D5DC, 0x1E8D6DC, 0x1E944E6, 0x1E945E6, 0x1E946E6, 0x1E947E6, 0x1E948E6,
+	0x1E949E6, 0x1E94A07,
+}
+
+// decompositions is the full canonical decomposition of each code point that has
+// one, Hangul syllables excepted.
+var decompositions = mapping{
+	keys: []rune{
+		0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C7, 0x00C8, 0x00C9, 0x00CA,
+		0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5,
+		0x00D6, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00E0, 0x00E1, 0x00E2, 0x00E3,
+		0x00E4, 0x00E5, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE,
+		0x00EF, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F9, 0x00FA, 0x00FB,
+		0x00FC, 0x00FD, 0x00FF, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106,
+		0x0107, 0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D, 0x010E, 0x010F, 0x0112,
+		0x0113, 0x0114, 0x0115, 0x0116, 0x0117, 0x0118, 0x0119, 0x011A, 0x011B, 0x011C,
+		0x011D, 0x011E, 0x011F, 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, 0x0128,
+		0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E, 0x012F, 0x0130, 0x0134, 0x0135,
+		0x0136, 0x0137, 0x0139, 0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0143, 0x0144,
+		0x0145, 0x0146, 0x0147, 0x0148, 0x014C, 0x014D, 0x014E, 0x014F, 0x0150, 0x0151,
+		0x0154, 0x0155, 0x0156, 0x0157, 0x0158, 0x0159, 0x015A, 0x015B, 0x015C, 0x015D,
+		0x015E, 0x015F, 0x0160, 0x0161, 0x0162, 0x0163, 0x0164, 0x0165, 0x0168, 0x0169,
+		0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F, 0x0170, 0x0171, 0x0172, 0x0173,
+		0x0174, 0x0175, 0x0176, 0x0177, 0x0178, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D,
+		0x017E, 0x01A0, 0x01A1, 0x01AF, 0x01B0, 0x01CD, 0x01CE, 0x01CF, 0x01D0, 0x01D1,
+		0x01D2, 0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB,
+		0x01DC, 0x01DE, 0x01DF, 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E6, 0x01E7, 0x01E8,
+		0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, 0x01F0, 0x01F4, 0x01F5,
+		0x01F8, 0x01F9, 0x01FA, 0x01FB, 0x01FC, 0x01FD, 0x01FE, 0x01FF, 0x0200, 0x0201,
+		0x0202, 0x0203, 0x0204, 0x0205, 0x0206, 0x0207, 0x0208, 0x0209, 0x020A, 0x020B,
+		0x020C, 0x020D, 0x020E, 0x020F, 0x0210, 0x0211, 0x0212, 0x0213, 0x0214, 0x0215,
+		0x0216, 0x0217, 0x0218, 0x0219, 0x021A, 0x021B, 0x021E, 0x021F, 0x0226, 0x0227,
+		0x0228, 0x0229, 0x022A, 0x022B, 0x022C, 0x022D, 0x022E, 0x022F, 0x0230, 0x0231,
+		0x0232, 0x0233, 0x0340, 0x0341, 0x0343, 0x0344, 0x0374, 0x037E, 0x0385, 0x0386,
+		0x0387, 0x0388, 0x0389, 0x038A, 0x038C, 0x038E, 0x038F, 0x0390, 0x03AA, 0x03AB,
+		0x03AC, 0x03AD, 0x03AE, 0x03AF, 0x03B0, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE,
+		0x03D3, 0x03D4, 0x0400, 0x0401, 0x0403, 0x0407, 0x040C, 0x040D, 0x040E, 0x0419,
+		0x0439, 0x0450, 0x0451, 0x0453, 0x0457, 0x045C, 0x045D, 0x045E, 0x0476, 0x0477,
+		0x04C1, 0x04C2, 0x04D0, 0x04D1, 0x04D2, 0x04D3, 0x04D6, 0x04D7, 0x04DA, 0x04DB,
+		0x04DC, 0x04DD, 0x04DE, 0x04DF, 0x04E2, 0x04E3, 0x04E4, 0x04E5, 0x04E6, 0x04E7,
+		0x04EA, 0x04EB, 0x04EC, 0x04ED, 0x04EE, 0x04EF, 0x04F0, 0x04F1, 0x04F2, 0x04F3,
+		0x04F4, 0x04F5, 0x04F8, 0x04F9, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x06C0,
+		0x06C2, 0x06D3, 0x0929, 0x0931, 0x0934, 0x0958, 0x0959, 0x095A, 0x095B, 0x095C,
+		0x095D, 0x095E, 0x095F, 0x09CB, 0x09CC, 0x09DC, 0x09DD, 0x09DF, 0x0A33, 0x0A36,
+		0x0A59, 0x0A5A, 0x0A5B, 0x0A5E, 0x0B48, 0x0B4B, 0x0B4C, 0x0B5C, 0x0B5D, 0x0B94,
+		0x0BCA, 0x0BCB, 0x0BCC, 0x0C48, 0x0CC0, 0x0CC7, 0x0CC8, 0x0CCA, 0x0CCB, 0x0D4A,
+		0x0D4B, 0x0D4C, 0x0DDA, 0x0DDC, 0x0DDD, 0x0DDE, 0x0F43, 0x0F4D, 0x0F52, 0x0F57,
+		0x0F5C, 0x0F69, 0x0F73, 0x0F75, 0x0F76, 0x0F78, 0x0F81, 0x0F93, 0x0F9D, 0x0FA2,
+		0x0FA7, 0x0FAC, 0x0FB9, 0x1026, 0x1B06, 0x1B08, 0x1B0A, 0x1B0C, 0x1B0E, 0x1B12,
+		0x1B3B, 0x1B3D, 0x1B40, 0x1B41, 0x1B43, 0x1E00, 0x1E01, 0x1E02, 0x1E03, 0x1E04,
+		0x1E05, 0x1E06, 0x1E07, 0x1E08, 0x1E09, 0x1E0A, 0x1E0B, 0x1E0C, 0x1E0D, 0x1E0E,
+		0x1E0F, 0x1E10, 0x1E11, 0x1E12, 0x1E13, 0x1E14, 0x1E15, 0x1E16, 0x1E17, 0x1E18,
+		0x1E19, 0x1E1A, 0x1E1B, 0x1E1C, 0x1E1D, 0x1E1E, 0x1E1F, 0x1E20, 0x1E21, 0x1E22,
+		0x1E23, 0x1E24, 0x1E25, 0x1E26, 0x1E27, 0x1E28, 0x1E29, 0x1E2A, 0x1E2B, 0x1E2C,
+		0x1E2D, 0x1E2E, 0x1E2F, 0x1E30, 0x1E31, 0x1E32, 0x1E33, 0x1E34, 0x1E35, 0x1E36,
+		0x1E37, 0x1E38, 0x1E39, 0x1E3A, 0x1E3B, 0x1E3C, 0x1E3D, 0x1E3E, 0x1E3F, 0x1E40,
+		0x1E41, 0x1E42, 0x1E43, 0x1E44, 0x1E45, 0x1E46, 0x1E47, 0x1E48, 0x1E49, 0x1E4A,
+		0x1E4B, 0x1E4C, 0x1E4D, 0x1E4E, 0x1E4F, 0x1E50, 0x1E51, 0x1E52, 0x1E53, 0x1E54,
+		0x1E55, 0x1E56, 0x1E57, 0x1E58, 0x1E59, 0x1E5A, 0x1E5B, 0x1E5C, 0x1E5D, 0x1E5E,
+		0x1E5F, 0x1E60, 0x1E61, 0x1E62, 0x1E63, 0x1E64, 0x1E65, 0x1E66, 0x1E67, 0x1E68,
+		0x1E69, 0x1E6A, 0x1E6B, 0x1E6C, 0x1E6D, 0x1E6E, 0x1E6F, 0x1E70, 0x1E71, 0x1E72,
+		0x1E73, 0x1E74, 0x1E75, 0x1E76, 0x1E77, 0x1E78, 0x1E79, 0x1E7A, 0x1E7B, 0x1E7C,
+		0x1E7D, 0x1E7E, 0x1E7F, 0x1E80, 0x1E81, 0x1E82, 0x1E83, 0x1E84, 0x1E85, 0x1E86,
+		0x1E87, 0x1E88, 0x1E89, 0x1E8A, 0x1E8B, 0x1E8C, 0x1E8D, 0x1E8E, 0x1E8F, 0x1E90,
+		0x1E91, 0x1E92, 0x1E93, 0x1E94, 0x1E95, 0x1E96, 0x1E97, 0x1E98, 0x1E99, 0x1E9B,
+		0x1EA0, 0x1EA1, 0x1EA2, 0x1EA3, 0x1EA4, 0x1EA5, 0x1EA6, 0x1EA7, 0x1EA8, 0x1EA9,
+		0x1EAA, 0x1EAB, 0x1EAC, 0x1EAD, 0x1EAE, 0x1EAF, 0x1EB0, 0x1EB1, 0x1EB2, 0x1EB3,
+		0x1EB4, 0x1EB5, 0x1EB6, 0x1EB7, 0x1EB8, 0x1EB9, 0x1EBA, 0x1EBB, 0x1EBC, 0x1EBD,
+		0x1EBE, 0x1EBF, 0x1EC0, 0x1EC1, 0x1EC2, 0x1EC3, 0x1EC4, 0x1EC5, 0x1EC6, 0x1EC7,
+		0x1EC8, 0x1EC9, 0x1ECA, 0x1ECB, 0x1ECC, 0x1ECD, 0x1ECE, 0x1ECF, 0x1ED0, 0x1ED1,
+		0x1ED2, 0x1ED3, 0x1ED4, 0x1ED5, 0x1ED6, 0x1ED7, 0x1ED8, 0x1ED9, 0x1EDA, 0x1EDB,
+		0x1EDC, 0x1EDD, 0x1EDE, 0x1EDF, 0x1EE0, 0x1EE1, 0x1EE2, 0x1EE3, 0x1EE4, 0x1EE5,
+		0x1EE6, 0x1EE7, 0x1EE8, 0x1EE9, 0x1EEA, 0x1EEB, 0x1EEC, 0x1EED, 0x1EEE, 0x1EEF,
+		0x1EF0, 0x1EF1, 0x1EF2, 0x1EF3, 0x1EF4, 0x1EF5, 0x1EF6, 0x1EF7, 0x1EF8, 0x1EF9,
+		0x1F00, 0x1F01, 0x1F02, 0x1F03, 0x1F04, 0x1F05, 0x1F06, 0x1F07, 0x1F08, 0x1F09,
+		0x1F0A, 0x1F0B, 0x1F0C, 0x1F0D, 0x1F0E, 0x1F0F, 0x1F10, 0x1F11, 0x1F12, 0x1F13,
+		0x1F14, 0x1F15, 0x1F18, 0x1F19, 0x1F1A, 0x1F1B, 0x1F1C, 0x1F1D, 0x1F20, 0x1F21,
+		0x1F22, 0x1F23, 0x1F24, 0x1F25, 0x1F26, 0x1F27, 0x1F28, 0x1F29, 0x1F2A, 0x1F2B,
+		0x1F2C, 0x1F2D, 0x1F2E, 0x1F2F, 0x1F30, 0x1F31, 0x1F32, 0x1F33, 0x1F34, 0x1F35,
+		0x1F36, 0x1F37, 0x1F38, 0x1F39, 0x1F3A, 0x1F3B, 0x1F3C, 0x1F3D, 0x1F3E, 0x1F3F,
+		0x1F40, 0x1F41, 0x1F42, 0x1F43, 0x1F44, 0x1F45, 0x1F48, 0x1F49, 0x1F4A, 0x1F4B,
+		0x1F4C, 0x1F4D, 0x1F50, 0x1F51, 0x1F52, 0x1F53, 0x1F54, 0x1F55, 0x1F56, 0x1F57,
+		0x1F59, 0x1F5B, 0x1F5D, 0x1F5F, 0x1F60, 0x1F61, 0x1F62, 0x1F63, 0x1F64, 0x1F65,
+		0x1F66, 0x1F67, 0x1F68, 0x1F69, 0x1F6A, 0x1F6B, 0x1F6C, 0x1F6D, 0x1F6E, 0x1F6F,
+		0x1F70, 0x1F71, 0x1F72, 0x1F73, 0x1F74, 0x1F75, 0x1F76, 0x1F77, 0x1F78, 0x1F79,
+		0x1F7A, 0x1F7B, 0x1F7C, 0x1F7D, 0x1F80, 0x1F81, 0x1F82, 0x1F83, 0x1F84, 0x1F85,
+		0x1F86, 0x1F87, 0x1F88, 0x1F89, 0x1F8A, 0x1F8B, 0x1F8C, 0x1F8D, 0x1F8E, 0x1F8F,
+		0x1F90, 0x1F91, 0x1F92, 0x1F93, 0x1F94, 0x1F95, 0x1F96, 0x1F97, 0x1F98, 0x1F99,
+		0x1F9A, 0x1F9B, 0x1F9C, 0x1F9D, 0x1F9E, 0x1F9F, 0x1FA0, 0x1FA1, 0x1FA2, 0x1FA3,
+		0x1FA4, 0x1FA5, 0x1FA6, 0x1FA7, 0x1FA8, 0x1FA9, 0x1FAA, 0x1FAB, 0x1FAC, 0x1FAD,
+		0x1FAE, 0x1FAF, 0x1FB0, 0x1FB1, 0x1FB2, 0x1FB3, 0x1FB4, 0x1FB6, 0x1FB7, 0x1FB8,
+		0x1FB9, 0x1FBA, 0x1FBB, 0x1FBC, 0x1FBE, 0x1FC1, 0x1FC2, 0x1FC3, 0x1FC4, 0x1FC6,
+		0x1FC7, 0x1FC8, 0x1FC9, 0x1FCA, 0x1FCB, 0x1FCC, 0x1FCD, 0x1FCE, 0x1FCF, 0x1FD0,
+		0x1FD1, 0x1FD2, 0x1FD3, 0x1FD6, 0x1FD7, 0x1FD8, 0x1FD9, 0x1FDA, 0x1FDB, 0x1FDD,
+		0x1FDE, 0x1FDF, 0x1FE0, 0x1FE1, 0x1FE2, 0x1FE3, 0x1FE4, 0x1FE5, 0x1FE6, 0x1FE7,
+		0x1FE8, 0x1FE9, 0x1FEA, 0x1FEB, 0x1FEC, 0x1FED, 0x1FEE, 0x1FEF, 0x1FF2, 0x1FF3,
+		0x1FF4, 0x1FF6, 0x1FF7, 0x1FF8, 0x1FF9, 0x1FFA, 0x1FFB, 0x1FFC, 0x1FFD, 0x2000,
+		0x2001, 0x2126, 0x212A, 0x212B, 0x219A, 0x219B, 0x21AE, 0x21CD, 0x21CE, 0x21CF,
+		0x2204, 0x2209, 0x220C, 0x2224, 0x2226, 0x2241, 0x2244, 0x2247, 0x2249, 0x2260,
+		0x2262, 0x226D, 0x226E, 0x226F, 0x2270, 0x2271, 0x2274, 0x2275, 0x2278, 0x2279,
+		0x2280, 0x2281, 0x2284, 0x2285, 0x2288, 0x2289, 0x22AC, 0x22AD, 0x22AE, 0x22AF,
+		0x22E0, 0x22E1, 0x22E2, 0x22E3, 0x22EA, 0x22EB, 0x22EC, 0x22ED, 0x2329, 0x232A,
+		0x2ADC, 0x304C, 0x304E, 0x3050, 0x3052, 0x3054, 0x3056, 0x3058, 0x305A, 0x305C,
+		0x305E, 0x3060, 0x3062, 0x3065, 0x3067, 0x3069, 0x3070, 0x3071, 0x3073, 0x3074,
+		0x3076, 0x3077, 0x3079, 0x307A, 0x307C, 0x307D, 0x3094, 0x309E, 0x30AC, 0x30AE,
+		0x30B0, 0x30B2, 0x30B4, 0x30B6, 0x30B8, 0x30BA, 0x30BC, 0x30BE, 0x30C0, 0x30C2,
+		0x30C5, 0x30C7, 0x30C9, 0x30D0, 0x30D1, 0x30D3, 0x30D4, 0x30D6, 0x30D7, 0x30D9,
+		0x30DA, 0x30DC, 0x30DD, 0x30F4, 0x30F7, 0x30F8, 0x30F9, 0x30FA, 0x30FE, 0xF900,
+		0xF901, 0xF902, 0xF903, 0xF904, 0xF905, 0xF906, 0xF907, 0xF908, 0xF909, 0xF90A,
+		0xF90B, 0xF90C, 0xF90D, 0xF90E, 0xF90F, 0xF910, 0xF911, 0xF912, 0xF913, 0xF914,
+		0xF915, 0xF916, 0xF917, 0xF918, 0xF919, 0xF91A, 0xF91B, 0xF91C, 0xF91D, 0xF91E,
+		0xF91F, 0xF920, 0xF921, 0xF922, 0xF923, 0xF924, 0xF925, 0xF926, 0xF927, 0xF928,
+		0xF929, 0xF92A, 0xF92B, 0xF92C, 0xF92D, 0xF92E, 0xF92F, 0xF930, 0xF931, 0xF932,
+		0xF933, 0xF934, 0xF935, 0xF936, 0xF937, 0xF938, 0xF939, 0xF93A, 0xF93B, 0xF93C,
+		0xF93D, 0xF93E, 0xF93F, 0xF940, 0xF941, 0xF942, 0xF943, 0xF944, 0xF945, 0xF946,
+		0xF947, 0xF948, 0xF949, 0xF94A, 0xF94B, 0xF94C, 0xF94D, 0xF94E, 0xF94F, 0xF950,
+		0xF951, 0xF952, 0xF953, 0xF954, 0xF955, 0xF956, 0xF957, 0xF958, 0xF959, 0xF95A,
+		0xF95B, 0xF95C, 0xF95D, 0xF95E, 0xF95F, 0xF960, 0xF961, 0xF962, 0xF963, 0xF964,
+		0xF965, 0xF966, 0xF967, 0xF968, 0xF969, 0xF96A, 0xF96B, 0xF96C, 0xF96D, 0xF96E,
+		0xF96F, 0xF970, 0xF971, 0xF972, 0xF973, 0xF974, 0xF975, 0xF976, 0xF977, 0xF978,
+		0xF979, 0xF97A, 0xF97B, 0xF97C, 0xF97D, 0xF97E, 0xF97F, 0xF980, 0xF981, 0xF982,
+		0xF983, 0xF984, 0xF985, 0xF986, 0xF987, 0xF988, 0xF989, 0xF98A, 0xF98B, 0xF98C,
+		0xF98D, 0xF98E, 0xF98F, 0xF990, 0xF991, 0xF992, 0xF993, 0xF994, 0xF995, 0xF996,
+		0xF997, 0xF998, 0xF999, 0xF99A, 0xF99B, 0xF99C, 0xF99D, 0xF99E, 0xF99F, 0xF9A0,
+		0xF9A1, 0xF9A2, 0xF9A3, 0xF9A4, 0xF9A5, 0xF9A6, 0xF9A7, 0xF9A8, 0xF9A9, 0xF9AA,
+		0xF9AB, 0xF9AC, 0xF9AD, 0xF9AE, 0xF9AF, 0xF9B0, 0xF9B1, 0xF9B2, 0xF9B3, 0xF9B4,
+		0xF9B5, 0xF9B6, 0xF9B7, 0xF9B8, 0xF9B9, 0xF9BA, 0xF9BB, 0xF9BC, 0xF9BD, 0xF9BE,
+		0xF9BF, 0xF9C0, 0xF9C1, 0xF9C2, 0xF9C3, 0xF9C4, 0xF9C5, 0xF9C6, 0xF9C7, 0xF9C8,
+		0xF9C9, 0xF9CA, 0xF9CB, 0xF9CC, 0xF9CD, 0xF9CE, 0xF9CF, 0xF9D0, 0xF9D1, 0xF9D2,
+		0xF9D3, 0xF9D4, 0xF9D5, 0xF9D6, 0xF9D7, 0xF9D8, 0xF9D9, 0xF9DA, 0xF9DB, 0xF9DC,
+		0xF9DD, 0xF9DE, 0xF9DF, 0xF9E0, 0xF9E1, 0xF9E2, 0xF9E3, 0xF9E4, 0xF9E5, 0xF9E6,
+		0xF9E7, 0xF9E8, 0xF9E9, 0xF9EA, 0xF9EB, 0xF9EC, 0xF9ED, 0xF9EE, 0xF9EF, 0xF9F0,
+		0xF9F1, 0xF9F2, 0xF9F3, 0xF9F4, 0xF9F5, 0xF9F6, 0xF9F7, 0xF9F8, 0xF9F9, 0xF9FA,
+		0xF9FB, 0xF9FC, 0xF9FD, 0xF9FE, 0xF9FF, 0xFA00, 0xFA01, 0xFA02, 0xFA03, 0xFA04,
+		0xFA05, 0xFA06, 0xFA07, 0xFA08, 0xFA09, 0xFA0A, 0xFA0B, 0xFA0C, 0xFA0D, 0xFA10,
+		0xFA12, 0xFA15, 0xFA16, 0xFA17, 0xFA18, 0xFA19, 0xFA1A, 0xFA1B, 0xFA1C, 0xFA1D,
+		0xFA1E, 0xFA20, 0xFA22, 0xFA25, 0xFA26, 0xFA2A, 0xFA2B, 0xFA2C, 0xFA2D, 0xFA2E,
+		0xFA2F, 0xFA30, 0xFA31, 0xFA32, 0xFA33, 0xFA34, 0xFA35, 0xFA36, 0xFA37, 0xFA38,
+		0xFA39, 0xFA3A, 0xFA3B, 0xFA3C, 0xFA3D, 0xFA3E, 0xFA3F, 0xFA40, 0xFA41, 0xFA42,
+		0xFA43, 0xFA44, 0xFA45, 0xFA46, 0xFA47, 0xFA48, 0xFA49, 0xFA4A, 0xFA4B, 0xFA4C,
+		0xFA4D, 0xFA4E, 0xFA4F, 0xFA50, 0xFA51, 0xFA52, 0xFA53, 0xFA54, 0xFA55, 0xFA56,
+		0xFA57, 0xFA58, 0xFA59, 0xFA5A, 0xFA5B, 0xFA5C, 0xFA5D, 0xFA5E, 0xFA5F, 0xFA60,
+		0xFA61, 0xFA62, 0xFA63, 0xFA64, 0xFA65, 0xFA66, 0xFA67, 0xFA68, 0xFA69, 0xFA6A,
+		0xFA6B, 0xFA6C, 0xFA6D, 0xFA70, 0xFA71, 0xFA72, 0xFA73, 0xFA74, 0xFA75, 0xFA76,
+		0xFA77, 0xFA78, 0xFA79, 0xFA7A, 0xFA7B, 0xFA7C, 0xFA7D, 0xFA7E, 0xFA7F, 0xFA80,
+		0xFA81, 0xFA82, 0xFA83, 0xFA84, 0xFA85, 0xFA86, 0xFA87, 0xFA88, 0xFA89, 0xFA8A,
+		0xFA8B, 0xFA8C, 0xFA8D, 0xFA8E, 0xFA8F, 0xFA90, 0xFA91, 0xFA92, 0xFA93, 0xFA94,
+		0xFA95, 0xFA96, 0xFA97, 0xFA98, 0xFA99, 0xFA9A, 0xFA9B, 0xFA9C, 0xFA9D, 0xFA9E,
+		0xFA9F, 0xFAA0, 0xFAA1, 0xFAA2, 0xFAA3, 0xFAA4, 0xFAA5, 0xFAA6, 0xFAA7, 0xFAA8,
+		0xFAA9, 0xFAAA, 0xFAAB, 0xFAAC, 0xFAAD, 0xFAAE, 0xFAAF, 0xFAB0, 0xFAB1, 0xFAB2,
+		0xFAB3, 0xFAB4, 0xFAB5, 0xFAB6, 0xFAB7, 0xFAB8, 0xFAB9, 0xFABA, 0xFABB, 0xFABC,
+		0xFABD, 0xFABE, 0xFABF, 0xFAC0, 0xFAC1, 0xFAC2, 0xFAC3, 0xFAC4, 0xFAC5, 0xFAC6,
+		0xFAC7, 0xFAC8, 0xFAC9, 0xFACA, 0xFACB, 0xFACC, 0xFACD, 0xFACE, 0xFACF, 0xFAD0,
+		0xFAD1, 0xFAD2, 0xFAD3, 0xFAD4, 0xFAD5, 0xFAD6, 0xFAD7, 0xFAD8, 0xFAD9, 0xFB1D,
+		0xFB1F, 0xFB2A, 0xFB2B, 0xFB2C, 0xFB2D, 0xFB2E, 0xFB2F, 0xFB30, 0xFB31, 0xFB32,
+		0xFB33, 0xFB34, 0xFB35, 0xFB36, 0xFB38, 0xFB39, 0xFB3A, 0xFB3B, 0xFB3C, 0xFB3E,
+		0xFB40, 0xFB41, 0xFB43, 0xFB44, 0xFB46, 0xFB47, 0xFB48, 0xFB49, 0xFB4A, 0xFB4B,
+		0xFB4C, 0xFB4D, 0xFB4E, 0x105C9, 0x105E4, 0x1109A, 0x1109C, 0x110AB, 0x1112E, 0x1112F,
+		0x1134B, 0x1134C, 0x11383, 0x11385, 0x1138E, 0x11391, 0x113C5, 0x113C7, 0x113C8, 0x114BB,
+		0x114BC, 0x114BE, 0x115BA, 0x115BB, 0x11938, 0x16121, 0x16122, 0x16123, 0x16124, 0x16125,
+		0x16126, 0x16127, 0x16128, 0x16D68, 0x16D69, 0x16D6A, 0x1D15E, 0x1D15F, 0x1D160, 0x1D161,
+		0x1D162, 0x1D163, 0x1D164, 0x1D1BB, 0x1D1BC, 0x1D1BD, 0x1D1BE, 0x1D1BF, 0x1D1C0, 0x2F800,
+		0x2F801, 0x2F802, 0x2F803, 0x2F804, 0x2F805, 0x2F806, 0x2F807, 0x2F808, 0x2F809, 0x2F80A,
+		0x2F80B, 0x2F80C, 0x2F80D, 0x2F80E, 0x2F80F, 0x2F810, 0x2F811, 0x2F812, 0x2F813, 0x2F814,
+		0x2F815, 0x2F816, 0x2F817, 0x2F818, 0x2F819, 0x2F81A, 0x2F81B, 0x2F81C, 0x2F81D, 0x2F81E,
+		0x2F81F, 0x2F820, 0x2F821, 0x2F822, 0x2F823, 0x2F824, 0x2F825, 0x2F826, 0x2F827, 0x2F828,
+		0x2F829, 0x2F82A, 0x2F82B, 0x2F82C, 0x2F82D, 0x2F82E, 0x2F82F, 0x2F830, 0x2F831, 0x2F832,
+		0x2F833, 0x2F834, 0x2F835, 0x2F836, 0x2F837, 0x2F838, 0x2F839, 0x2F83A, 0x2F83B, 0x2F83C,
+		0x2F83D, 0x2F83E, 0x2F83F, 0x2F840, 0x2F841, 0x2F842, 0x2F843, 0x2F844, 0x2F845, 0x2F846,
+		0x2F847, 0x2F848, 0x2F849, 0x2F84A, 0x2F84B, 0x2F84C, 0x2F84D, 0x2F84E, 0x2F84F, 0x2F850,
+		0x2F851, 0x2F852, 0x2F853, 0x2F854, 0x2F855, 0x2F856, 0x2F857, 0x2F858, 0x2F859, 0x2F85A,
+		0x2F85B, 0x2F85C, 0x2F85D, 0x2F85E, 0x2F85F, 0x2F860, 0x2F861, 0x2F862, 0x2F863, 0x2F864,
+		0x2F865, 0x2F866, 0x2F867, 0x2F868, 0x2F869, 0x2F86A, 0x2F86B, 0x2F86C, 0x2F86D, 0x2F86E,
+		0x2F86F, 0x2F870, 0x2F871, 0x2F872, 0x2F873, 0x2F874, 0x2F875, 0x2F876, 0x2F877, 0x2F878,
+		0x2F879, 0x2F87A, 0x2F87B, 0x2F87C, 0x2F87D, 0x2F87E, 0x2F87F, 0x2F880, 0x2F881, 0x2F882,
+		0x2F883, 0x2F884, 0x2F885, 0x2F886, 0x2F887, 0x2F888, 0x2F889, 0x2F88A, 0x2F88B, 0x2F88C,
+		0x2F88D, 0x2F88E, 0x2F88F, 0x2F890, 0x2F891, 0x2F892, 0x2F893, 0x2F894, 0x2F895, 0x2F896,
+		0x2F897, 0x2F898, 0x2F899, 0x2F89A, 0x2F89B, 0x2F89C, 0x2F89D, 0x2F89E, 0x2F89F, 0x2F8A0,
+		0x2F8A1, 0x2F8A2, 0x2F8A3, 0x2F8A4, 0x2F8A5, 0x2F8A6, 0x2F8A7, 0x2F8A8, 0x2F8A9, 0x2F8AA,
+		0x2F8AB, 0x2F8AC, 0x2F8AD, 0x2F8AE, 0x2F8AF, 0x2F8B0, 0x2F8B1, 0x2F8B2, 0x2F8B3, 0x2F8B4,
+		0x2F8B5, 0x2F8B6, 0x2F8B7, 0x2F8B8, 0x2F8B9, 0x2F8BA, 0x2F8BB, 0x2F8BC, 0x2F8BD, 0x2F8BE,
+		0x2F8BF, 0x2F8C0, 0x2F8C1, 0x2F8C2, 0x2F8C3, 0x2F8C4, 0x2F8C5, 0x2F8C6, 0x2F8C7, 0x2F8C8,
+		0x2F8C9, 0x2F8CA, 0x2F8CB, 0x2F8CC, 0x2F8CD, 0x2F8CE, 0x2F8CF, 0x2F8D0, 0x2F8D1, 0x2F8D2,
+		0x2F8D3, 0x2F8D4, 0x2F8D5, 0x2F8D6, 0x2F8D7, 0x2F8D8, 0x2F8D9, 0x2F8DA, 0x2F8DB, 0x2F8DC,
+		0x2F8DD, 0x2F8DE, 0x2F8DF, 0x2F8E0, 0x2F8E1, 0x2F8E2, 0x2F8E3, 0x2F8E4, 0x2F8E5, 0x2F8E6,
+		0x2F8E7, 0x2F8E8, 0x2F8E9, 0x2F8EA, 0x2F8EB, 0x2F8EC, 0x2F8ED, 0x2F8EE, 0x2F8EF, 0x2F8F0,
+		0x2F8F1, 0x2F8F2, 0x2F8F3, 0x2F8F4, 0x2F8F5, 0x2F8F6, 0x2F8F7, 0x2F8F8, 0x2F8F9, 0x2F8FA,
+		0x2F8FB, 0x2F8FC, 0x2F8FD, 0x2F8FE, 0x2F8FF, 0x2F900, 0x2F901, 0x2F902, 0x2F903, 0x2F904,
+		0x2F905, 0x2F906, 0x2F907, 0x2F908, 0x2F909, 0x2F90A, 0x2F90B, 0x2F90C, 0x2F90D, 0x2F90E,
+		0x2F90F, 0x2F910, 0x2F911, 0x2F912, 0x2F913, 0x2F914, 0x2F915, 0x2F916, 0x2F917, 0x2F918,
+		0x2F919, 0x2F91A, 0x2F91B, 0x2F91C, 0x2F91D, 0x2F91E, 0x2F91F, 0x2F920, 0x2F921, 0x2F922,
+		0x2F923, 0x2F924, 0x2F925, 0x2F926, 0x2F927, 0x2F928, 0x2F929, 0x2F92A, 0x2F92B, 0x2F92C,
+		0x2F92D, 0x2F92E, 0x2F92F, 0x2F930, 0x2F931, 0x2F932, 0x2F933, 0x2F934, 0x2F935, 0x2F936,
+		0x2F937, 0x2F938, 0x2F939, 0x2F93A, 0x2F93B, 0x2F93C, 0x2F93D, 0x2F93E, 0x2F93F, 0x2F940,
+		0x2F941, 0x2F942, 0x2F943, 0x2F944, 0x2F945, 0x2F946, 0x2F947, 0x2F948, 0x2F949, 0x2F94A,
+		0x2F94B, 0x2F94C, 0x2F94D, 0x2F94E, 0x2F94F, 0x2F950, 0x2F951, 0x2F952, 0x2F953, 0x2F954,
+		0x2F955, 0x2F956, 0x2F957, 0x2F958, 0x2F959, 0x2F95A, 0x2F95B, 0x2F95C, 0x2F95D, 0x2F95E,
+		0x2F95F, 0x2F960, 0x2F961, 0x2F962, 0x2F963, 0x2F964, 0x2F965, 0x2F966, 0x2F967, 0x2F968,
+		0x2F969, 0x2F96A, 0x2F96B, 0x2F96C, 0x2F96D, 0x2F96E, 0x2F96F, 0x2F970, 0x2F971, 0x2F972,
+		0x2F973, 0x2F974, 0x2F975, 0x2F976, 0x2F977, 0x2F978, 0x2F979, 0x2F97A, 0x2F97B, 0x2F97C,
+		0x2F97D, 0x2F97E, 0x2F97F, 0x2F980, 0x2F981, 0x2F982, 0x2F983, 0x2F984, 0x2F985, 0x2F986,
+		0x2F987, 0x2F988, 0x2F989, 0x2F98A, 0x2F98B, 0x2F98C, 0x2F98D, 0x2F98E, 0x2F98F, 0x2F990,
+		0x2F991, 0x2F992, 0x2F993, 0x2F994, 0x2F995, 0x2F996, 0x2F997, 0x2F998, 0x2F999, 0x2F99A,
+		0x2F99B, 0x2F99C, 0x2F99D, 0x2F99E, 0x2F99F, 0x2F9A0, 0x2F9A1, 0x2F9A2, 0x2F9A3, 0x2F9A4,
+		0x2F9A5, 0x2F9A6, 0x2F9A7, 0x2F9A8, 0x2F9A9, 0x2F9AA, 0x2F9AB, 0x2F9AC, 0x2F9AD, 0x2F9AE,
+		0x2F9AF, 0x2F9B0, 0x2F9B1, 0x2F9B2, 0x2F9B3, 0x2F9B4, 0x2F9B5, 0x2F9B6, 0x2F9B7, 0x2F9B8,
+		0x2F9B9, 0x2F9BA, 0x2F9BB, 0x2F9BC, 0x2F9BD, 0x2F9BE, 0x2F9BF, 0x2F9C0, 0x2F9C1, 0x2F9C2,
+		0x2F9C3, 0x2F9C4, 0x2F9C5, 0x2F9C6, 0x2F9C7, 0x2F9C8, 0x2F9C9, 0x2F9CA, 0x2F9CB, 0x2F9CC,
+		0x2F9CD, 0x2F9CE, 0x2F9CF, 0x2F9D0, 0x2F9D1, 0x2F9D2, 0x2F9D3, 0x2F9D4, 0x2F9D5, 0x2F9D6,
+		0x2F9D7, 0x2F9D8, 0x2F9D9, 0x2F9DA, 0x2F9DB, 0x2F9DC, 0x2F9DD, 0x2F9DE, 0x2F9DF, 0x2F9E0,
+		0x2F9E1, 0x2F9E2, 0x2F9E3, 0x2F9E4, 0x2F9E5, 0x2F9E6, 0x2F9E7, 0x2F9E8, 0x2F9E9, 0x2F9EA,
+		0x2F9EB, 0x2F9EC, 0x2F9ED, 0x2F9EE, 0x2F9EF, 0x2F9F0, 0x2F9F1, 0x2F9F2, 0x2F9F3, 0x2F9F4,
+		0x2F9F5, 0x2F9F6, 0x2F9F7, 0x2F9F8, 0x2F9F9, 0x2F9FA, 0x2F9FB, 0x2F9FC, 0x2F9FD, 0x2F9FE,
+		0x2F9FF, 0x2FA00, 0x2FA01, 0x2FA02, 0x2FA03, 0x2FA04, 0x2FA05, 0x2FA06, 0x2FA07, 0x2FA08,
+		0x2FA09, 0x2FA0A, 0x2FA0B, 0x2FA0C, 0x2FA0D, 0x2FA0E, 0x2FA0F, 0x2FA10, 0x2FA11, 0x2FA12,
+		0x2FA13, 0x2FA14, 0x2FA15, 0x2FA16, 0x2FA17, 0x2FA18, 0x2FA19, 0x2FA1A, 0x2FA1B, 0x2FA1C,
+		0x2FA1D,
+	},
+	start: []uint16{
+		0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
+		24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46,
+		48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70,
+		72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94,
+		96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118,
+		120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142,
+		144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166,
+		168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190,
+		192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214,
+		216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238,
+		240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262,
+		264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286,
+		288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310,
+		312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334,
+		336, 338, 340, 342, 344, 346, 349, 352, 355, 358, 361, 364,
+		367, 370, 373, 376, 379, 382, 384, 386, 388, 390, 392, 394,
+		396, 398, 401, 404, 406, 408, 410, 412, 414, 416, 418, 421,
+		424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446,
+		448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470,
+		472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494,
+		496, 498, 500, 503, 506, 509, 512, 514, 516, 519, 522, 524,
+		526, 527, 528, 529, 531, 532, 533, 535, 537, 538, 540, 542,
+		544, 546, 548, 550, 553, 555, 557, 559, 561, 563, 565, 568,
+		570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592,
+		594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616,
+		618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640,
+		642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664,
+		666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688,
+		690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712,
+		714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736,
+		738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760,
+		762, 764, 766, 768, 770, 772, 774, 777, 779, 781, 783, 785,
+		787, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810,
+		812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834,
+		836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858,
+		860, 862, 864, 866, 869, 872, 874, 876, 878, 880, 882, 884,
+		886, 888, 890, 892, 895, 898, 901, 904, 906, 908, 910, 912,
+		915, 918, 920, 922, 924, 926, 928, 930, 932, 934, 936, 938,
+		940, 942, 944, 946, 948, 950, 953, 956, 958, 960, 962, 964,
+		966, 968, 970, 972, 975, 978, 980, 982, 984, 986, 988, 990,
+		992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014,
+		1017, 1020, 1023, 1026, 1029, 1032, 1035, 1038, 1040, 1042, 1044, 1046,
+		1048, 1050, 1052, 1054, 1057, 1060, 1062, 1064, 1066, 1068, 1070, 1072,
+		1075, 1078, 1081, 1084, 1087, 1090, 1092, 1094, 1096, 1098, 1100, 1102,
+		1104, 1106, 1108, 1110, 1112, 1114, 1116, 1118, 1121, 1124, 1127, 1130,
+		1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154,
+		1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178,
+		1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1203,
+		1206, 1209, 1212, 1215, 1218, 1221, 1224, 1227, 1230, 1233, 1236, 1239,
+		1242, 1245, 1248, 1251, 1254, 1257, 1260, 1262, 1264, 1266, 1268, 1270,
+		1272, 1275, 1278, 1281, 1284, 1287, 1290, 1293, 1296, 1299, 1302, 1304,
+		1306, 1308, 1310, 1312, 1314, 1316, 1318, 1321, 1324, 1327, 1330, 1333,
+		1336, 1339, 1342, 1345, 1348, 1351, 1354, 1357, 1360, 1363, 1366, 1369,
+		1372, 1375, 1378, 1380, 1382, 1384, 1386, 1389, 1392, 1395, 1398, 1401,
+		1404, 1407, 1410, 1413, 1416, 1418, 1420, 1422, 1424, 1426, 1428, 1430,
+		1432, 1434, 1436, 1439, 1442, 1445, 1448, 1451, 1454, 1456, 1458, 1461,
+		1464, 1467, 1470, 1473, 1476, 1478, 1480, 1483, 1486, 1489, 1492, 1494,
+		1496, 1499, 1502, 1505, 1508, 1510, 1512, 1515, 1518, 1521, 1524, 1527,
+		1530, 1532, 1534, 1537, 1540, 1543, 1546, 1549, 1552, 1554, 1556, 1559,
+		1562, 1565, 1568, 1571, 1574, 1576, 1578, 1581, 1584, 1587, 1590, 1593,
+		1596, 1598, 1600, 1603, 1606, 1609, 1612, 1614, 1616, 1619, 1622, 1625,
+		1628, 1630, 1632, 1635, 1638, 1641, 1644, 1647, 1650, 1652, 1655, 1658,
+		1661, 1663, 1665, 1668, 1671, 1674, 1677, 1680, 1683, 1685, 1687, 1690,
+		1693, 1696, 1699, 1702, 1705, 1707, 1709, 1711, 1713, 1715, 1717, 1719,
+		1721, 1723, 1725, 1727, 1729, 1731, 1733, 1736, 1739, 1743, 1747, 1751,
+		1755, 1759, 1763, 1766, 1769, 1773, 1777, 1781, 1785, 1789, 1793, 1796,
+		1799, 1803, 1807, 1811, 1815, 1819, 1823, 1826, 1829, 1833, 1837, 1841,
+		1845, 1849, 1853, 1856, 1859, 1863, 1867, 1871, 1875, 1879, 1883, 1886,
+		1889, 1893, 1897, 1901, 1905, 1909, 1913, 1915, 1917, 1920, 1922, 1925,
+		1927, 1930, 1932, 1934, 1936, 1938, 1940, 1941, 1943, 1946, 1948, 1951,
+		1953, 1956, 1958, 1960, 1962, 1964, 1966, 1968, 1970, 1972, 1974, 1976,
+		1979, 1982, 1984, 1987, 1989, 1991, 1993, 1995, 1997, 1999, 2001, 2003,
+		2005, 2008, 2011, 2013, 2015, 2017, 2020, 2022, 2024, 2026, 2028, 2030,
+		2032, 2034, 2035, 2038, 2040, 2043, 2045, 2048, 2050, 2052, 2054, 2056,
+		2058, 2059, 2060, 2061, 2062, 2063, 2065, 2067, 2069, 2071, 2073, 2075,
+		2077, 2079, 2081, 2083, 2085, 2087, 2089, 2091, 2093, 2095, 2097, 2099,
+		2101, 2103, 2105, 2107, 2109, 2111, 2113, 2115, 2117, 2119, 2121, 2123,
+		2125, 2127, 2129, 2131, 2133, 2135, 2137, 2139, 2141, 2143, 2145, 2147,
+		2149, 2151, 2153, 2154, 2155, 2157, 2159, 2161, 2163, 2165, 2167, 2169,
+		2171, 2173, 2175, 2177, 2179, 2181, 2183, 2185, 2187, 2189, 2191, 2193,
+		2195, 2197, 2199, 2201, 2203, 2205, 2207, 2209, 2211, 2213, 2215, 2217,
+		2219, 2221, 2223, 2225, 2227, 2229, 2231, 2233, 2235, 2237, 2239, 2241,
+		2243, 2245, 2247, 2249, 2251, 2253, 2255, 2257, 2259, 2261, 2263, 2265,
+		2267, 2269, 2271, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281,
+		2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293,
+		2294, 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305,
+		2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317,
+		2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329,
+		2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341,
+		2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353,
+		2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365,
+		2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377,
+		2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389,
+		2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401,
+		2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413,
+		2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425,
+		2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437,
+		2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449,
+		2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 2461,
+		2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473,
+		2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485,
+		2486, 2487, 2488, 2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497,
+		2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, 2506, 2507, 2508, 2509,
+		2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521,
+		2522, 2523, 2524, 2525, 2526, 2527, 2528, 2529, 2530, 2531, 2532, 2533,
+		2534, 2535, 2536, 2537, 2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545,
+		2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553, 2554, 2555, 2556, 2557,
+		2558, 2559, 2560, 2561, 2562, 2563, 2564, 2565, 2566, 2567, 2568, 2569,
+		2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581,
+		2582, 2583, 2584, 2585, 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593,
+		2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2604, 2605,
+		2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617,
+		2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629,
+		2630, 2631, 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2639, 2640, 2641,
+		2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 2650, 2651, 2652, 2653,
+		2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, 2664, 2665,
+		2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677,
+		2678, 2679, 2680, 2681, 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689,
+		2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697, 2698, 2699, 2700, 2701,
+		2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713,
+		2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725,
+		2726, 2727, 2728, 2729, 2730, 2731, 2732, 2733, 2735, 2737, 2739, 2741,
+		2744, 2747, 2749, 2751, 2753, 2755, 2757, 2759, 2761, 2763, 2765, 2767,
+		2769, 2771, 2773, 2775, 2777, 2779, 2781, 2783, 2785, 2787, 2789, 2791,
+		2793, 2795, 2797, 2799, 2801, 2803, 2805, 2807, 2809, 2811, 2813, 2815,
+		2817, 2819, 2821, 2823, 2825, 2827, 2829, 2831, 2833, 2835, 2837, 2839,
+		2841, 2843, 2845, 2847, 2849, 2851, 2853, 2855, 2857, 2860, 2863, 2866,
+		2868, 2870, 2873, 2875, 2877, 2880, 2883, 2886, 2889, 2892, 2894, 2896,
+		2899, 2902, 2905, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916,
+		2917, 2918, 2919, 2920, 2921, 2922, 2923, 2924, 2925, 2926, 2927, 2928,
+		2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, 2940,
+		2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952,
+		2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964,
+		2965, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976,
+		2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985, 2986, 2987, 2988,
+		2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000,
+		3001, 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012,
+		3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020, 3021, 3022, 3023, 3024,
+		3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036,
+		3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048,
+		3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060,
+		3061, 3062, 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072,
+		3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, 3082, 3083, 3084,
+		3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096,
+		3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108,
+		3109, 3110, 3111, 3112, 3113, 3114, 3115, 3116, 3117, 3118, 3119, 3120,
+		3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129, 3130, 3131, 3132,
+		3133, 3134, 3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144,
+		3145, 3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153, 3154, 3155, 3156,
+		3157, 3158, 3159, 3160, 3161, 3162, 3163, 3164, 3165, 3166, 3167, 3168,
+		3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177, 3178, 3179, 3180,
+		3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192,
+		3193, 3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204,
+		3205, 3206, 3207, 3208, 3209, 3210, 3211, 3212, 3213, 3214, 3215, 3216,
+		3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225, 3226, 3227, 3228,
+		3229, 3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240,
+		3241, 3242, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 3250, 3251, 3252,
+		3253, 3254, 3255, 3256, 3257, 3258, 3259, 3260, 3261, 3262, 3263, 3264,
+		3265, 3266, 3267, 3268, 3269, 3270, 3271, 3272, 3273, 3274, 3275, 3276,
+		3277, 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286, 3287, 3288,
+		3289, 3290, 3291, 3292, 3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300,
+		3301, 3302, 3303, 3304, 3305, 3306, 3307, 3308, 3309, 3310, 3311, 3312,
+		3313, 3314, 3315, 3316, 3317, 3318, 3319, 3320, 3321, 3322, 3323, 3324,
+		3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334, 3335, 3336,
+		3337, 3338, 3339, 3340, 3341, 3342, 3343, 3344, 3345, 3346, 3347, 3348,
+		3349, 3350, 3351, 3352, 3353, 3354, 3355, 3356, 3357, 3358, 3359, 3360,
+		3361, 3362, 3363, 3364, 3365, 3366, 3367, 3368, 3369, 3370, 3371, 3372,
+		3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382, 3383, 3384,
+		3385, 3386, 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396,
+		3397, 3398, 3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406, 3407, 3408,
+		3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3417, 3418, 3419, 3420,
+		3421, 3422, 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432,
+		3433, 3434, 3435, 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3444,
+		3445, 3446, 3447, 3448, 3449, 3450,
+	},
+	data: []rune{
+		0x0041, 0x0300, 0x0041, 0x0301, 0x0041, 0x0302, 0x0041, 0x0303, 0x0041, 0x0308,
+		0x0041, 0x030A, 0x0043, 0x0327, 0x0045, 0x0300, 0x0045, 0x0301, 0x0045, 0x0302,
+		0x0045, 0x0308, 0x0049, 0x0300, 0x0049, 0x0301, 0x0049, 0x0302, 0x0049, 0x0308,
+		0x004E, 0x0303, 0x004F, 0x0300, 0x004F, 0x0301, 0x004F, 0x0302, 0x004F, 0x0303,
+		0x004F, 0x0308, 0x0055, 0x0300, 0x0055, 0x0301, 0x0055, 0x0302, 0x0055, 0x0308,
+		0x0059, 0x0301, 0x0061, 0x0300, 0x0061, 0x0301, 0x0061, 0x0302, 0x0061, 0x0303,
+		0x0061, 0x0308, 0x0061, 0x030A, 0x0063, 0x0327, 0x0065, 0x0300, 0x0065, 0x0301,
+		0x0065, 0x0302, 0x0065, 0x0308, 0x0069, 0x0300, 0x0069, 0x0301, 0x0069, 0x0302,
+		0x0069, 0x0308, 0x006E, 0x0303, 0x006F, 0x0300, 0x006F, 0x0301, 0x006F, 0x0302,
+		0x006F, 0x0303, 0x006F, 0x0308, 0x0075, 0x0300, 0x0075, 0x0301, 0x0075, 0x0302,
+		0x0075, 0x0308, 0x0079, 0x0301, 0x0079, 0x0308, 0x0041, 0x0304, 0x0061, 0x0304,
+		0x0041, 0x0306, 0x0061, 0x0306, 0x0041, 0x0328, 0x0061, 0x0328, 0x0043, 0x0301,
+		0x0063, 0x0301, 0x0043, 0x0302, 0x0063, 0x0302, 0x0043, 0x0307, 0x0063, 0x0307,
+		0x0043, 0x030C, 0x0063, 0x030C, 0x0044, 0x030C, 0x0064, 0x030C, 0x0045, 0x0304,
+		0x0065, 0x0304, 0x0045, 0x0306, 0x0065, 0x0306, 0x0045, 0x0307, 0x0065, 0x0307,
+		0x0045, 0x0328, 0x0065, 0x0328, 0x0045, 0x030C, 0x0065, 0x030C, 0x0047, 0x0302,
+		0x0067, 0x0302, 0x0047, 0x0306, 0x0067, 0x0306, 0x0047, 0x0307, 0x0067, 0x0307,
+		0x0047, 0x0327, 0x0067, 0x0327, 0x0048, 0x0302, 0x0068, 0x0302, 0x0049, 0x0303,
+		0x0069, 0x0303, 0x0049, 0x0304, 0x0069, 0x0304, 0x0049, 0x0306, 0x0069, 0x0306,
+		0x0049, 0x0328, 0x0069, 0x0328, 0x0049, 0x0307, 0x004A, 0x0302, 0x006A, 0x0302,
+		0x004B, 0x0327, 0x006B, 0x0327, 0x004C, 0x0301, 0x006C, 0x0301, 0x004C, 0x0327,
+		0x006C, 0x0327, 0x004C, 0x030C, 0x006C, 0x030C, 0x004E, 0x0301, 0x006E, 0x0301,
+		0x004E, 0x0327, 0x006E, 0x0327, 0x004E, 0x030C, 0x006E, 0x030C, 0x004F, 0x0304,
+		0x006F, 0x0304, 0x004F, 0x0306, 0x006F, 0x0306, 0x004F, 0x030B, 0x006F, 0x030B,
+		0x0052, 0x0301, 0x0072, 0x0301, 0x0052, 0x0327, 0x0072, 0x0327, 0x0052, 0x030C,
+		0x0072, 0x030C, 0x0053, 0x0301, 0x0073, 0x0301, 0x0053, 0x0302, 0x0073, 0x0302,
+		0x0053, 0x0327, 0x0073, 0x0327, 0x0053, 0x030C, 0x0073, 0x030C, 0x0054, 0x0327,
+		0x0074, 0x0327, 0x0054, 0x030C, 0x0074, 0x030C, 0x0055, 0x0303, 0x0075, 0x0303,
+		0x0055, 0x0304, 0x0075, 0x0304, 0x0055, 0x0306, 0x0075, 0x0306, 0x0055, 0x030A,
+		0x0075, 0x030A, 0x0055, 0x030B, 0x0075, 0x030B, 0x0055, 0x0328, 0x0075, 0x0328,
+		0x0057, 0x0302, 0x0077, 0x0302, 0x0059, 0x0302, 0x0079, 0x0302, 0x0059, 0x0308,
+		0x005A, 0x0301, 0x007A, 0x0301, 0x005A, 0x0307, 0x007A, 0x0307, 0x005A, 0x030C,
+		0x007A, 0x030C, 0x004F, 0x031B, 0x006F, 0x031B, 0x0055, 0x031B, 0x0075, 0x031B,
+		0x0041, 0x030C, 0x0061, 0x030C, 0x0049, 0x030C, 0x0069, 0x030C, 0x004F, 0x030C,
+		0x006F, 0x030C, 0x0055, 0x030C, 0x0075, 0x030C, 0x0055, 0x0308, 0x0304, 0x0075,
+		0x0308, 0x0304, 0x0055, 0x0308, 0x0301, 0x0075, 0x0308, 0x0301, 0x0055, 0x0308,
+		0x030C, 0x0075, 0x0308, 0x030C, 0x0055, 0x0308, 0x0300, 0x0075, 0x0308, 0x0300,
+		0x0041, 0x0308, 0x0304, 0x0061, 0x0308, 0x0304, 0x0041, 0x0307, 0x0304, 0x0061,
+		0x0307, 0x0304, 0x00C6, 0x0304, 0x00E6, 0x0304, 0x0047, 0x030C, 0x0067, 0x030C,
+		0x004B, 0x030C, 0x006B, 0x030C, 0x004F, 0x0328, 0x006F, 0x0328, 0x004F, 0x0328,
+		0x0304, 0x006F, 0x0328, 0x0304, 0x01B7, 0x030C, 0x0292, 0x030C, 0x006A, 0x030C,
+		0x0047, 0x0301, 0x0067, 0x0301, 0x004E, 0x0300, 0x006E, 0x0300, 0x0041, 0x030A,
+		0x0301, 0x0061, 0x030A, 0x0301, 0x00C6, 0x0301, 0x00E6, 0x0301, 0x00D8, 0x0301,
+		0x00F8, 0x0301, 0x0041, 0x030F, 0x0061, 0x030F, 0x0041, 0x0311, 0x0061, 0x0311,
+		0x0045, 0x030F, 0x0065, 0x030F, 0x0045, 0x0311, 0x0065, 0x0311, 0x0049, 0x030F,
+		0x0069, 0x030F, 0x0049, 0x0311, 0x0069, 0x0311, 0x004F, 0x030F, 0x006F, 0x030F,
+		0x004F, 0x0311, 0x006F, 0x0311, 0x0052, 0x030F, 0x0072, 0x030F, 0x0052, 0x0311,
+		0x0072, 0x0311, 0x0055, 0x030F, 0x0075, 0x030F, 0x0055, 0x0311, 0x0075, 0x0311,
+		0x0053, 0x0326, 0x0073, 0x0326, 0x0054, 0x0326, 0x0074, 0x0326, 0x0048, 0x030C,
+		0x0068, 0x030C, 0x0041, 0x0307, 0x0061, 0x0307, 0x0045, 0x0327, 0x0065, 0x0327,
+		0x004F, 0x0308, 0x0304, 0x006F, 0x0308, 0x0304, 0x004F, 0x0303, 0x0304, 0x006F,
+		0x0303, 0x0304, 0x004F, 0x0307, 0x006F, 0x0307, 0x004F, 0x0307, 0x0304, 0x006F,
+		0x0307, 0x0304, 0x0059, 0x0304, 0x0079, 0x0304, 0x0300, 0x0301, 0x0313, 0x0308,
+		0x0301, 0x02B9, 0x003B, 0x00A8, 0x0301, 0x0391, 0x0301, 0x00B7, 0x0395, 0x0301,
+		0x0397, 0x0301, 0x0399, 0x0301, 0x039F, 0x0301, 0x03A5, 0x0301, 0x03A9, 0x0301,
+		0x03B9, 0x0308, 0x0301, 0x0399, 0x0308, 0x03A5, 0x0308, 0x03B1, 0x0301, 0x03B5,
+		0x0301, 0x03B7, 0x0301, 0x03B9, 0x0301, 0x03C5, 0x0308, 0x0301, 0x03B9, 0x0308,
+		0x03C5, 0x0308, 0x03BF, 0x0301, 0x03C5, 0x0301, 0x03C9, 0x0301, 0x03D2, 0x0301,
+		0x03D2, 0x0308, 0x0415, 0x0300, 0x0415, 0x0308, 0x0413, 0x0301, 0x0406, 0x0308,
+		0x041A, 0x0301, 0x0418, 0x0300, 0x0423, 0x0306, 0x0418, 0x0306, 0x0438, 0x0306,
+		0x0435, 0x0300, 0x0435, 0x0308, 0x0433, 0x0301, 0x0456, 0x0308, 0x043A, 0x0301,
+		0x0438, 0x0300, 0x0443, 0x0306, 0x0474, 0x030F, 0x0475, 0x030F, 0x0416, 0x0306,
+		0x0436, 0x0306, 0x0410, 0x0306, 0x0430, 0x0306, 0x0410, 0x0308, 0x0430, 0x0308,
+		0x0415, 0x0306, 0x0435, 0x0306, 0x04D8, 0x0308, 0x04D9, 0x0308, 0x0416, 0x0308,
+		0x0436, 0x0308, 0x0417, 0x0308, 0x0437, 0x0308, 0x0418, 0x0304, 0x0438, 0x0304,
+		0x0418, 0x0308, 0x0438, 0x0308, 0x041E, 0x0308, 0x043E, 0x0308, 0x04E8, 0x0308,
+		0x04E9, 0x0308, 0x042D, 0x0308, 0x044D, 0x0308, 0x0423, 0x0304, 0x0443, 0x0304,
+		0x0423, 0x0308, 0x0443, 0x0308, 0x0423, 0x030B, 0x0443, 0x030B, 0x0427, 0x0308,
+		0x0447, 0x0308, 0x042B, 0x0308, 0x044B, 0x0308, 0x0627, 0x0653, 0x0627, 0x0654,
+		0x0648, 0x0654, 0x0627, 0x0655, 0x064A, 0x0654, 0x06D5, 0x0654, 0x06C1, 0x0654,
+		0x06D2, 0x0654, 0x0928, 0x093C, 0x0930, 0x093C, 0x0933, 0x093C, 0x0915, 0x093C,
+		0x0916, 0x093C, 0x0917, 0x093C, 0x091C, 0x093C, 0x0921, 0x093C, 0x0922, 0x093C,
+		0x092B, 0x093C, 0x092F, 0x093C, 0x09C7, 0x09BE, 0x09C7, 0x09D7, 0x09A1, 0x09BC,
+		0x09A2, 0x09BC, 0x09AF, 0x09BC, 0x0A32, 0x0A3C, 0x0A38, 0x0A3C, 0x0A16, 0x0A3C,
+		0x0A17, 0x0A3C, 0x0A1C, 0x0A3C, 0x0A2B, 0x0A3C, 0x0B47, 0x0B56, 0x0B47, 0x0B3E,
+		0x0B47, 0x0B57, 0x0B21, 0x0B3C, 0x0B22, 0x0B3C, 0x0B92, 0x0BD7, 0x0BC6, 0x0BBE,
+		0x0BC7, 0x0BBE, 0x0BC6, 0x0BD7, 0x0C46, 0x0C56, 0x0CBF, 0x0CD5, 0x0CC6, 0x0CD5,
+		0x0CC6, 0x0CD6, 0x0CC6, 0x0CC2, 0x0CC6, 0x0CC2, 0x0CD5, 0x0D46, 0x0D3E, 0x0D47,
+		0x0D3E, 0x0D46, 0x0D57, 0x0DD9, 0x0DCA, 0x0DD9, 0x0DCF, 0x0DD9, 0x0DCF, 0x0DCA,
+		0x0DD9, 0x0DDF, 0x0F42, 0x0FB7, 0x0F4C, 0x0FB7, 0x0F51, 0x0FB7, 0x0F56, 0x0FB7,
+		0x0F5B, 0x0FB7, 0x0F40, 0x0FB5, 0x0F71, 0x0F72, 0x0F71, 0x0F74, 0x0FB2, 0x0F80,
+		0x0FB3, 0x0F80, 0x0F71, 0x0F80, 0x0F92, 0x0FB7, 0x0F9C, 0x0FB7, 0x0FA1, 0x0FB7,
+		0x0FA6, 0x0FB7, 0x0FAB, 0x0FB7, 0x0F90, 0x0FB5, 0x1025, 0x102E, 0x1B05, 0x1B35,
+		0x1B07, 0x1B35, 0x1B09, 0x1B35, 0x1B0B, 0x1B35, 0x1B0D, 0x1B35, 0x1B11, 0x1B35,
+		0x1B3A, 0x1B35, 0x1B3C, 0x1B35, 0x1B3E, 0x1B35, 0x1B3F, 0x1B35, 0x1B42, 0x1B35,
+		0x0041, 0x0325, 0x0061, 0x0325, 0x0042, 0x0307, 0x0062, 0x0307, 0x0042, 0x0323,
+		0x0062, 0x0323, 0x0042, 0x0331, 0x0062, 0x0331, 0x0043, 0x0327, 0x0301, 0x0063,
+		0x0327, 0x0301, 0x0044, 0x0307, 0x0064, 0x0307, 0x0044, 0x0323, 0x0064, 0x0323,
+		0x0044, 0x0331, 0x0064, 0x0331, 0x0044, 0x0327, 0x0064, 0x0327, 0x0044, 0x032D,
+		0x0064, 0x032D, 0x0045, 0x0304, 0x0300, 0x0065, 0x0304, 0x0300, 0x0045, 0x0304,
+		0x0301, 0x0065, 0x0304, 0x0301, 0x0045, 0x032D, 0x0065, 0x032D, 0x0045, 0x0330,
+		0x0065, 0x0330, 0x0045, 0x0327, 0x0306, 0x0065, 0x0327, 0x0306, 0x0046, 0x0307,
+		0x0066, 0x0307, 0x0047, 0x0304, 0x0067, 0x0304, 0x0048, 0x0307, 0x0068, 0x0307,
+		0x0048, 0x0323, 0x0068, 0x0323, 0x0048, 0x0308, 0x0068, 0x0308, 0x0048, 0x0327,
+		0x0068, 0x0327, 0x0048, 0x032E, 0x0068, 0x032E, 0x0049, 0x0330, 0x0069, 0x0330,
+		0x0049, 0x0308, 0x0301, 0x0069, 0x0308, 0x0301, 0x004B, 0x0301, 0x006B, 0x0301,
+		0x004B, 0x0323, 0x006B, 0x0323, 0x004B, 0x0331, 0x006B, 0x0331, 0x004C, 0x0323,
+		0x006C, 0x0323, 0x004C, 0x0323, 0x0304, 0x006C, 0x0323, 0x0304, 0x004C, 0x0331,
+		0x006C, 0x0331, 0x004C, 0x032D, 0x006C, 0x032D, 0x004D, 0x0301, 0x006D, 0x0301,
+		0x004D, 0x0307, 0x006D, 0x0307, 0x004D, 0x0323, 0x006D, 0x0323, 0x004E, 0x0307,
+		0x006E, 0x0307, 0x004E, 0x0323, 0x006E, 0x0323, 0x004E, 0x0331, 0x006E, 0x0331,
+		0x004E, 0x032D, 0x006E, 0x032D, 0x004F, 0x0303, 0x0301, 0x006F, 0x0303, 0x0301,
+		0x004F, 0x0303, 0x0308, 0x006F, 0x0303, 0x0308, 0x004F, 0x0304, 0x0300, 0x006F,
+		0x0304, 0x0300, 0x004F, 0x0304, 0x0301, 0x006F, 0x0304, 0x0301, 0x0050, 0x0301,
+		0x0070, 0x0301, 0x0050, 0x0307, 0x0070, 0x0307, 0x0052, 0x0307, 0x0072, 0x0307,
+		0x0052, 0x0323, 0x0072, 0x0323, 0x0052, 0x0323, 0x0304, 0x0072, 0x0323, 0x0304,
+		0x0052, 0x0331, 0x0072, 0x0331, 0x0053, 0x0307, 0x0073, 0x0307, 0x0053, 0x0323,
+		0x0073, 0x0323, 0x0053, 0x0301, 0x0307, 0x0073, 0x0301, 0x0307, 0x0053, 0x030C,
+		0x0307, 0x0073, 0x030C, 0x0307, 0x0053, 0x0323, 0x0307, 0x0073, 0x0323, 0x0307,
+		0x0054, 0x0307, 0x0074, 0x0307, 0x0054, 0x0323, 0x0074, 0x0323, 0x0054, 0x0331,
+		0x0074, 0x0331, 0x0054, 0x032D, 0x0074, 0x032D, 0x0055, 0x0324, 0x0075, 0x0324,
+		0x0055, 0x0330, 0x0075, 0x0330, 0x0055, 0x032D, 0x0075, 0x032D, 0x0055, 0x0303,
+		0x0301, 0x0075, 0x0303, 0x0301, 0x0055, 0x0304, 0x0308, 0x0075, 0x0304, 0x0308,
+		0x0056, 0x0303, 0x0076, 0x0303, 0x0056, 0x0323, 0x0076, 0x0323, 0x0057, 0x0300,
+		0x0077, 0x0300, 0x0057, 0x0301, 0x0077, 0x0301, 0x0057, 0x0308, 0x0077, 0x0308,
+		0x0057, 0x0307, 0x0077, 0x0307, 0x0057, 0x0323, 0x0077, 0x0323, 0x0058, 0x0307,
+		0x0078, 0x0307, 0x0058, 0x0308, 0x0078, 0x0308, 0x0059, 0x0307, 0x0079, 0x0307,
+		0x005A, 0x0302, 0x007A, 0x0302, 0x005A, 0x0323, 0x007A, 0x0323, 0x005A, 0x0331,
+		0x007A, 0x0331, 0x0068, 0x0331, 0x0074, 0x0308, 0x0077, 0x030A, 0x0079, 0x030A,
+		0x017F, 0x0307, 0x0041, 0x0323, 0x0061, 0x0323, 0x0041, 0x0309, 0x0061, 0x0309,
+		0x0041, 0x0302, 0x0301, 0x0061, 0x0302, 0x0301, 0x0041, 0x0302, 0x0300, 0x0061,
+		0x0302, 0x0300, 0x0041, 0x0302, 0x0309, 0x0061, 0x0302, 0x0309, 0x0041, 0x0302,
+		0x0303, 0x0061, 0x0302, 0x0303, 0x0041, 0x0323, 0x0302, 0x0061, 0x0323, 0x0302,
+		0x0041, 0x0306, 0x0301, 0x0061, 0x0306, 0x0301, 0x0041, 0x0306, 0x0300, 0x0061,
+		0x0306, 0x0300, 0x0041, 0x0306, 0x0309, 0x0061, 0x0306, 0x0309, 0x0041, 0x0306,
+		0x0303, 0x0061, 0x0306, 0x0303, 0x0041, 0x0323, 0x0306, 0x0061, 0x0323, 0x0306,
+		0x0045, 0x0323, 0x0065, 0x0323, 0x0045, 0x0309, 0x0065, 0x0309, 0x0045, 0x0303,
+		0x0065, 0x0303, 0x0045, 0x0302, 0x0301, 0x0065, 0x0302, 0x0301, 0x0045, 0x0302,
+		0x0300, 0x0065, 0x0302, 0x0300, 0x0045, 0x0302, 0x0309, 0x0065, 0x0302, 0x0309,
+		0x0045, 0x0302, 0x0303, 0x0065, 0x0302, 0x0303, 0x0045, 0x0323, 0x0302, 0x0065,
+		0x0323, 0x0302, 0x0049, 0x0309, 0x0069, 0x0309, 0x0049, 0x0323, 0x0069, 0x0323,
+		0x004F, 0x0323, 0x006F, 0x0323, 0x004F, 0x0309, 0x006F, 0x0309, 0x004F, 0x0302,
+		0x0301, 0x006F, 0x0302, 0x0301, 0x004F, 0x0302, 0x0300, 0x006F, 0x0302, 0x0300,
+		0x004F, 0x0302, 0x0309, 0x006F, 0x0302, 0x0309, 0x004F, 0x0302, 0x0303, 0x006F,
+		0x0302, 0x0303, 0x004F, 0x0323, 0x0302, 0x006F, 0x0323, 0x0302, 0x004F, 0x031B,
+		0x0301, 0x006F, 0x031B, 0x0301, 0x004F, 0x031B, 0x0300, 0x006F, 0x031B, 0x0300,
+		0x004F, 0x031B, 0x0309, 0x006F, 0x031B, 0x0309, 0x004F, 0x031B, 0x0303, 0x006F,
+		0x031B, 0x0303, 0x004F, 0x031B, 0x0323, 0x006F, 0x031B, 0x0323, 0x0055, 0x0323,
+		0x0075, 0x0323, 0x0055, 0x0309, 0x0075, 0x0309, 0x0055, 0x031B, 0x0301, 0x0075,
+		0x031B, 0x0301, 0x0055, 0x031B, 0x0300, 0x0075, 0x031B, 0x0300, 0x0055, 0x031B,
+		0x0309, 0x0075, 0x031B, 0x0309, 0x0055, 0x031B, 0x0303, 0x0075, 0x031B, 0x0303,
+		0x0055, 0x031B, 0x0323, 0x0075, 0x031B, 0x0323, 0x0059, 0x0300, 0x0079, 0x0300,
+		0x0059, 0x0323, 0x0079, 0x0323, 0x0059, 0x0309, 0x0079, 0x0309, 0x0059, 0x0303,
+		0x0079, 0x0303, 0x03B1, 0x0313, 0x03B1, 0x0314, 0x03B1, 0x0313, 0x0300, 0x03B1,
+		0x0314, 0x0300, 0x03B1, 0x0313, 0x0301, 0x03B1, 0x0314, 0x0301, 0x03B1, 0x0313,
+		0x0342, 0x03B1, 0x0314, 0x0342, 0x0391, 0x0313, 0x0391, 0x0314, 0x0391, 0x0313,
+		0x0300, 0x0391, 0x0314, 0x0300, 0x0391, 0x0313, 0x0301, 0x0391, 0x0314, 0x0301,
+		0x0391, 0x0313, 0x0342, 0x0391, 0x0314, 0x0342, 0x03B5, 0x0313, 0x03B5, 0x0314,
+		0x03B5, 0x0313, 0x0300, 0x03B5, 0x0314, 0x0300, 0x03B5, 0x0313, 0x0301, 0x03B5,
+		0x0314, 0x0301, 0x0395, 0x0313, 0x0395, 0x0314, 0x0395, 0x0313, 0x0300, 0x0395,
+		0x0314, 0x0300, 0x0395, 0x0313, 0x0301, 0x0395, 0x0314, 0x0301, 0x03B7, 0x0313,
+		0x03B7, 0x0314, 0x03B7, 0x0313, 0x0300, 0x03B7, 0x0314, 0x0300, 0x03B7, 0x0313,
+		0x0301, 0x03B7, 0x0314, 0x0301, 0x03B7, 0x0313, 0x0342, 0x03B7, 0x0314, 0x0342,
+		0x0397, 0x0313, 0x0397, 0x0314, 0x0397, 0x0313, 0x0300, 0x0397, 0x0314, 0x0300,
+		0x0397, 0x0313, 0x0301, 0x0397, 0x0314, 0x0301, 0x0397, 0x0313, 0x0342, 0x0397,
+		0x0314, 0x0342, 0x03B9, 0x0313, 0x03B9, 0x0314, 0x03B9, 0x0313, 0x0300, 0x03B9,
+		0x0314, 0x0300, 0x03B9, 0x0313, 0x0301, 0x03B9, 0x0314, 0x0301, 0x03B9, 0x0313,
+		0x0342, 0x03B9, 0x0314, 0x0342, 0x0399, 0x0313, 0x0399, 0x0314, 0x0399, 0x0313,
+		0x0300, 0x0399, 0x0314, 0x0300, 0x0399, 0x0313, 0x0301, 0x0399, 0x0314, 0x0301,
+		0x0399, 0x0313, 0x0342, 0x0399, 0x0314, 0x0342, 0x03BF, 0x0313, 0x03BF, 0x0314,
+		0x03BF, 0x0313, 0x0300, 0x03BF, 0x0314, 0x0300, 0x03BF, 0x0313, 0x0301, 0x03BF,
+		0x0314, 0x0301, 0x039F, 0x0313, 0x039F, 0x0314, 0x039F, 0x0313, 0x0300, 0x039F,
+		0x0314, 0x0300, 0x039F, 0x0313, 0x0301, 0x039F, 0x0314, 0x0301, 0x03C5, 0x0313,
+		0x03C5, 0x0314, 0x03C5, 0x0313, 0x0300, 0x03C5, 0x0314, 0x0300, 0x03C5, 0x0313,
+		0x0301, 0x03C5, 0x0314, 0x0301, 0x03C5, 0x0313, 0x0342, 0x03C5, 0x0314, 0x0342,
+		0x03A5, 0x0314, 0x03A5, 0x0314, 0x0300, 0x03A5, 0x0314, 0x0301, 0x03A5, 0x0314,
+		0x0342, 0x03C9, 0x0313, 0x03C9, 0x0314, 0x03C9, 0x0313, 0x0300, 0x03C9, 0x0314,
+		0x0300, 0x03C9, 0x0313, 0x0301, 0x03C9, 0x0314, 0x0301, 0x03C9, 0x0313, 0x0342,
+		0x03C9, 0x0314, 0x0342, 0x03A9, 0x0313, 0x03A9, 0x0314, 0x03A9, 0x0313, 0x0300,
+		0x03A9, 0x0314, 0x0300, 0x03A9, 0x0313, 0x0301, 0x03A9, 0x0314, 0x0301, 0x03A9,
+		0x0313, 0x0342, 0x03A9, 0x0314, 0x0342, 0x03B1, 0x0300, 0x03B1, 0x0301, 0x03B5,
+		0x0300, 0x03B5, 0x0301, 0x03B7, 0x0300, 0x03B7, 0x0301, 0x03B9, 0x0300, 0x03B9,
+		0x0301, 0x03BF, 0x0300, 0x03BF, 0x0301, 0x03C5, 0x0300, 0x03C5, 0x0301, 0x03C9,
+		0x0300, 0x03C9, 0x0301, 0x03B1, 0x0313, 0x0345, 0x03B1, 0x0314, 0x0345, 0x03B1,
+		0x0313, 0x0300, 0x0345, 0x03B1, 0x0314, 0x0300, 0x0345, 0x03B1, 0x0313, 0x0301,
+		0x0345, 0x03B1, 0x0314, 0x0301, 0x0345, 0x03B1, 0x0313, 0x0342, 0x0345, 0x03B1,
+		0x0314, 0x0342, 0x0345, 0x0391, 0x0313, 0x0345, 0x0391, 0x0314, 0x0345, 0x0391,
+		0x0313, 0x0300, 0x0345, 0x0391, 0x0314, 0x0300, 0x0345, 0x0391, 0x0313, 0x0301,
+		0x0345, 0x0391, 0x0314, 0x0301, 0x0345, 0x0391, 0x0313, 0x0342, 0x0345, 0x0391,
+		0x0314, 0x0342, 0x0345, 0x03B7, 0x0313, 0x0345, 0x03B7, 0x0314, 0x0345, 0x03B7,
+		0x0313, 0x0300, 0x0345, 0x03B7, 0x0314, 0x0300, 0x0345, 0x03B7, 0x0313, 0x0301,
+		0x0345, 0x03B7, 0x0314, 0x0301, 0x0345, 0x03B7, 0x0313, 0x0342, 0x0345, 0x03B7,
+		0x0314, 0x0342, 0x0345, 0x0397, 0x0313, 0x0345, 0x0397, 0x0314, 0x0345, 0x0397,
+		0x0313, 0x0300, 0x0345, 0x0397, 0x0314, 0x0300, 0x0345, 0x0397, 0x0313, 0x0301,
+		0x0345, 0x0397, 0x0314, 0x0301, 0x0345, 0x0397, 0x0313, 0x0342, 0x0345, 0x0397,
+		0x0314, 0x0342, 0x0345, 0x03C9, 0x0313, 0x0345, 0x03C9, 0x0314, 0x0345, 0x03C9,
+		0x0313, 0x0300, 0x0345, 0x03C9, 0x0314, 0x0300, 0x0345, 0x03C9, 0x0313, 0x0301,
+		0x0345, 0x03C9, 0x0314, 0x0301, 0x0345, 0x03C9, 0x0313, 0x0342, 0x0345, 0x03C9,
+		0x0314, 0x0342, 0x0345, 0x03A9, 0x0313, 0x0345, 0x03A9, 0x0314, 0x0345, 0x03A9,
+		0x0313, 0x0300, 0x0345, 0x03A9, 0x0314, 0x0300, 0x0345, 0x03A9, 0x0313, 0x0301,
+		0x0345, 0x03A9, 0x0314, 0x0301, 0x0345, 0x03A9, 0x0313, 0x0342, 0x0345, 0x03A9,
+		0x0314, 0x0342, 0x0345, 0x03B1, 0x0306, 0x03B1, 0x0304, 0x03B1, 0x0300, 0x0345,
+		0x03B1, 0x0345, 0x03B1, 0x0301, 0x0345, 0x03B1, 0x0342, 0x03B1, 0x0342, 0x0345,
+		0x0391, 0x0306, 0x0391, 0x0304, 0x0391, 0x0300, 0x0391, 0x0301, 0x0391, 0x0345,
+		0x03B9, 0x00A8, 0x0342, 0x03B7, 0x0300, 0x0345, 0x03B7, 0x0345, 0x03B7, 0x0301,
+		0x0345, 0x03B7, 0x0342, 0x03B7, 0x0342, 0x0345, 0x0395, 0x0300, 0x0395, 0x0301,
+		0x0397, 0x0300, 0x0397, 0x0301, 0x0397, 0x0345, 0x1FBF, 0x0300, 0x1FBF, 0x0301,
+		0x1FBF, 0x0342, 0x03B9, 0x0306, 0x03B9, 0x0304, 0x03B9, 0x0308, 0x0300, 0x03B9,
+		0x0308, 0x0301, 0x03B9, 0x0342, 0x03B9, 0x0308, 0x0342, 0x0399, 0x0306, 0x0399,
+		0x0304, 0x0399, 0x0300, 0x0399, 0x0301, 0x1FFE, 0x0300, 0x1FFE, 0x0301, 0x1FFE,
+		0x0342, 0x03C5, 0x0306, 0x03C5, 0x0304, 0x03C5, 0x0308, 0x0300, 0x03C5, 0x0308,
+		0x0301, 0x03C1, 0x0313, 0x03C1, 0x0314, 0x03C5, 0x0342, 0x03C5, 0x0308, 0x0342,
+		0x03A5, 0x0306, 0x03A5, 0x0304, 0x03A5, 0x0300, 0x03A5, 0x0301, 0x03A1, 0x0314,
+		0x00A8, 0x0300, 0x00A8, 0x0301, 0x0060, 0x03C9, 0x0300, 0x0345, 0x03C9, 0x0345,
+		0x03C9, 0x0301, 0x0345, 0x03C9, 0x0342, 0x03C9, 0x0342, 0x0345, 0x039F, 0x0300,
+		0x039F, 0x0301, 0x03A9, 0x0300, 0x03A9, 0x0301, 0x03A9, 0x0345, 0x00B4, 0x2002,
+		0x2003, 0x03A9, 0x004B, 0x0041, 0x030A, 0x2190, 0x0338, 0x2192, 0x0338, 0x2194,
+		0x0338, 0x21D0, 0x0338, 0x21D4, 0x0338, 0x21D2, 0x0338, 0x2203, 0x0338, 0x2208,
+		0x0338, 0x220B, 0x0338, 0x2223, 0x0338, 0x2225, 0x0338, 0x223C, 0x0338, 0x2243,
+		0x0338, 0x2245, 0x0338, 0x2248, 0x0338, 0x003D, 0x0338, 0x2261, 0x0338, 0x224D,
+		0x0338, 0x003C, 0x0338, 0x003E, 0x0338, 0x2264, 0x0338, 0x2265, 0x0338, 0x2272,
+		0x0338, 0x2273, 0x0338, 0x2276, 0x0338, 0x2277, 0x0338, 0x227A, 0x0338, 0x227B,
+		0x0338, 0x2282, 0x0338, 0x2283, 0x0338, 0x2286, 0x0338, 0x2287, 0x0338, 0x22A2,
+		0x0338, 0x22A8, 0x0338, 0x22A9, 0x0338, 0x22AB, 0x0338, 0x227C, 0x0338, 0x227D,
+		0x0338, 0x2291, 0x0338, 0x2292, 0x0338, 0x22B2, 0x0338, 0x22B3, 0x0338, 0x22B4,
+		0x0338, 0x22B5, 0x0338, 0x3008, 0x3009, 0x2ADD, 0x0338, 0x304B, 0x3099, 0x304D,
+		0x3099, 0x304F, 0x3099, 0x3051, 0x3099, 0x3053, 0x3099, 0x3055, 0x3099, 0x3057,
+		0x3099, 0x3059, 0x3099, 0x305B, 0x3099, 0x305D, 0x3099, 0x305F, 0x3099, 0x3061,
+		0x3099, 0x3064, 0x3099, 0x3066, 0x3099, 0x3068, 0x3099, 0x306F, 0x3099, 0x306F,
+		0x309A, 0x3072, 0x3099, 0x3072, 0x309A, 0x3075, 0x3099, 0x3075, 0x309A, 0x3078,
+		0x3099, 0x3078, 0x309A, 0x307B, 0x3099, 0x307B, 0x309A, 0x3046, 0x3099, 0x309D,
+		0x3099, 0x30AB, 0x3099, 0x30AD, 0x3099, 0x30AF, 0x3099, 0x30B1, 0x3099, 0x30B3,
+		0x3099, 0x30B5, 0x3099, 0x30B7, 0x3099, 0x30B9, 0x3099, 0x30BB, 0x3099, 0x30BD,
+		0x3099, 0x30BF, 0x3099, 0x30C1, 0x3099, 0x30C4, 0x3099, 0x30C6, 0x3099, 0x30C8,
+		0x3099, 0x30CF, 0x3099, 0x30CF, 0x309A, 0x30D2, 0x3099, 0x30D2, 0x309A, 0x30D5,
+		0x3099, 0x30D5, 0x309A, 0x30D8, 0x3099, 0x30D8, 0x309A, 0x30DB, 0x3099, 0x30DB,
+		0x309A, 0x30A6, 0x3099, 0x30EF, 0x3099, 0x30F0, 0x3099, 0x30F1, 0x3099, 0x30F2,
+		0x3099, 0x30FD, 0x3099, 0x8C48, 0x66F4, 0x8ECA, 0x8CC8, 0x6ED1, 0x4E32, 0x53E5,
+		0x9F9C, 0x9F9C, 0x5951, 0x91D1, 0x5587, 0x5948, 0x61F6, 0x7669, 0x7F85, 0x863F,
+		0x87BA, 0x88F8, 0x908F, 0x6A02, 0x6D1B, 0x70D9, 0x73DE, 0x843D, 0x916A, 0x99F1,
+		0x4E82, 0x5375, 0x6B04, 0x721B, 0x862D, 0x9E1E, 0x5D50, 0x6FEB, 0x85CD, 0x8964,
+		0x62C9, 0x81D8, 0x881F, 0x5ECA, 0x6717, 0x6D6A, 0x72FC, 0x90CE, 0x4F86, 0x51B7,
+		0x52DE, 0x64C4, 0x6AD3, 0x7210, 0x76E7, 0x8001, 0x8606, 0x865C, 0x8DEF, 0x9732,
+		0x9B6F, 0x9DFA, 0x788C, 0x797F, 0x7DA0, 0x83C9, 0x9304, 0x9E7F, 0x8AD6, 0x58DF,
+		0x5F04, 0x7C60, 0x807E, 0x7262, 0x78CA, 0x8CC2, 0x96F7, 0x58D8, 0x5C62, 0x6A13,
+		0x6DDA, 0x6F0F, 0x7D2F, 0x7E37, 0x964B, 0x52D2, 0x808B, 0x51DC, 0x51CC, 0x7A1C,
+		0x7DBE, 0x83F1, 0x9675, 0x8B80, 0x62CF, 0x6A02, 0x8AFE, 0x4E39, 0x5BE7, 0x6012,
+		0x7387, 0x7570, 0x5317, 0x78FB, 0x4FBF, 0x5FA9, 0x4E0D, 0x6CCC, 0x6578, 0x7D22,
+		0x53C3, 0x585E, 0x7701, 0x8449, 0x8AAA, 0x6BBA, 0x8FB0, 0x6C88, 0x62FE, 0x82E5,
+		0x63A0, 0x7565, 0x4EAE, 0x5169, 0x51C9, 0x6881, 0x7CE7, 0x826F, 0x8AD2, 0x91CF,
+		0x52F5, 0x5442, 0x5973, 0x5EEC, 0x65C5, 0x6FFE, 0x792A, 0x95AD, 0x9A6A, 0x9E97,
+		0x9ECE, 0x529B, 0x66C6, 0x6B77, 0x8F62, 0x5E74, 0x6190, 0x6200, 0x649A, 0x6F23,
+		0x7149, 0x7489, 0x79CA, 0x7DF4, 0x806F, 0x8F26, 0x84EE, 0x9023, 0x934A, 0x5217,
+		0x52A3, 0x54BD, 0x70C8, 0x88C2, 0x8AAA, 0x5EC9, 0x5FF5, 0x637B, 0x6BAE, 0x7C3E,
+		0x7375, 0x4EE4, 0x56F9, 0x5BE7, 0x5DBA, 0x601C, 0x73B2, 0x7469, 0x7F9A, 0x8046,
+		0x9234, 0x96F6, 0x9748, 0x9818, 0x4F8B, 0x79AE, 0x91B4, 0x96B8, 0x60E1, 0x4E86,
+		0x50DA, 0x5BEE, 0x5C3F, 0x6599, 0x6A02, 0x71CE, 0x7642, 0x84FC, 0x907C, 0x9F8D,
+		0x6688, 0x962E, 0x5289, 0x677B, 0x67F3, 0x6D41, 0x6E9C, 0x7409, 0x7559, 0x786B,
+		0x7D10, 0x985E, 0x516D, 0x622E, 0x9678, 0x502B, 0x5D19, 0x6DEA, 0x8F2A, 0x5F8B,
+		0x6144, 0x6817, 0x7387, 0x9686, 0x5229, 0x540F, 0x5C65, 0x6613, 0x674E, 0x68A8,
+		0x6CE5, 0x7406, 0x75E2, 0x7F79, 0x88CF, 0x88E1, 0x91CC, 0x96E2, 0x533F, 0x6EBA,
+		0x541D, 0x71D0, 0x7498, 0x85FA, 0x96A3, 0x9C57, 0x9E9F, 0x6797, 0x6DCB, 0x81E8,
+		0x7ACB, 0x7B20, 0x7C92, 0x72C0, 0x7099, 0x8B58, 0x4EC0, 0x8336, 0x523A, 0x5207,
+		0x5EA6, 0x62D3, 0x7CD6, 0x5B85, 0x6D1E, 0x66B4, 0x8F3B, 0x884C, 0x964D, 0x898B,
+		0x5ED3, 0x5140, 0x55C0, 0x585A, 0x6674, 0x51DE, 0x732A, 0x76CA, 0x793C, 0x795E,
+		0x7965, 0x798F, 0x9756, 0x7CBE, 0x7FBD, 0x8612, 0x8AF8, 0x9038, 0x90FD, 0x98EF,
+		0x98FC, 0x9928, 0x9DB4, 0x90DE, 0x96B7, 0x4FAE, 0x50E7, 0x514D, 0x52C9, 0x52E4,
+		0x5351, 0x559D, 0x5606, 0x5668, 0x5840, 0x58A8, 0x5C64, 0x5C6E, 0x6094, 0x6168,
+		0x618E, 0x61F2, 0x654F, 0x65E2, 0x6691, 0x6885, 0x6D77, 0x6E1A, 0x6F22, 0x716E,
+		0x722B, 0x7422, 0x7891, 0x793E, 0x7949, 0x7948, 0x7950, 0x7956, 0x795D, 0x798D,
+		0x798E, 0x7A40, 0x7A81, 0x7BC0, 0x7DF4, 0x7E09, 0x7E41, 0x7F72, 0x8005, 0x81ED,
+		0x8279, 0x8279, 0x8457, 0x8910, 0x8996, 0x8B01, 0x8B39, 0x8CD3, 0x8D08, 0x8FB6,
+		0x9038, 0x96E3, 0x97FF, 0x983B, 0x6075, 0x242EE, 0x8218, 0x4E26, 0x51B5, 0x5168,
+		0x4F80, 0x5145, 0x5180, 0x52C7, 0x52FA, 0x559D, 0x5555, 0x5599, 0x55E2, 0x585A,
+		0x58B3, 0x5944, 0x5954, 0x5A62, 0x5B28, 0x5ED2, 0x5ED9, 0x5F69, 0x5FAD, 0x60D8,
+		0x614E, 0x6108, 0x618E, 0x6160, 0x61F2, 0x6234, 0x63C4, 0x641C, 0x6452, 0x6556,
+		0x6674, 0x6717, 0x671B, 0x6756, 0x6B79, 0x6BBA, 0x6D41, 0x6EDB, 0x6ECB, 0x6F22,
+		0x701E, 0x716E, 0x77A7, 0x7235, 0x72AF, 0x732A, 0x7471, 0x7506, 0x753B, 0x761D,
+		0x761F, 0x76CA, 0x76DB, 0x76F4, 0x774A, 0x7740, 0x78CC, 0x7AB1, 0x7BC0, 0x7C7B,
+		0x7D5B, 0x7DF4, 0x7F3E, 0x8005, 0x8352, 0x83EF, 0x8779, 0x8941, 0x8986, 0x8996,
+		0x8ABF, 0x8AF8, 0x8ACB, 0x8B01, 0x8AFE, 0x8AED, 0x8B39, 0x8B8A, 0x8D08, 0x8F38,
+		0x9072, 0x9199, 0x9276, 0x967C, 0x96E3, 0x9756, 0x97DB, 0x97FF, 0x980B, 0x983B,
+		0x9B12, 0x9F9C, 0x2284A, 0x22844, 0x233D5, 0x3B9D, 0x4018, 0x4039, 0x25249, 0x25CD0,
+		0x27ED3, 0x9F43, 0x9F8E, 0x05D9, 0x05B4, 0x05F2, 0x05B7, 0x05E9, 0x05C1, 0x05E9,
+		0x05C2, 0x05E9, 0x05BC, 0x05C1, 0x05E9, 0x05BC, 0x05C2, 0x05D0, 0x05B7, 0x05D0,
+		0x05B8, 0x05D0, 0x05BC, 0x05D1, 0x05BC, 0x05D2, 0x05BC, 0x05D3, 0x05BC, 0x05D4,
+		0x05BC, 0x05D5, 0x05BC, 0x05D6, 0x05BC, 0x05D8, 0x05BC, 0x05D9, 0x05BC, 0x05DA,
+		0x05BC, 0x05DB, 0x05BC, 0x05DC, 0x05BC, 0x05DE, 0x05BC, 0x05E0, 0x05BC, 0x05E1,
+		0x05BC, 0x05E3, 0x05BC, 0x05E4, 0x05BC, 0x05E6, 0x05BC, 0x05E7, 0x05BC, 0x05E8,
+		0x05BC, 0x05E9, 0x05BC, 0x05EA, 0x05BC, 0x05D5, 0x05B9, 0x05D1, 0x05BF, 0x05DB,
+		0x05BF, 0x05E4, 0x05BF, 0x105D2, 0x0307, 0x105DA, 0x0307, 0x11099, 0x110BA, 0x1109B,
+		0x110BA, 0x110A5, 0x110BA, 0x11131, 0x11127, 0x11132, 0x11127, 0x11347, 0x1133E, 0x11347,
+		0x11357, 0x11382, 0x113C9, 0x11384, 0x113BB, 0x1138B, 0x113C2, 0x11390, 0x113C9, 0x113C2,
+		0x113C2, 0x113C2, 0x113B8, 0x113C2, 0x113C9, 0x114B9, 0x114BA, 0x114B9, 0x114B0, 0x114B9,
+		0x114BD, 0x115B8, 0x115AF, 0x115B9, 0x115AF, 0x11935, 0x11930, 0x1611E, 0x1611E, 0x1611E,
+		0x16129, 0x1611E, 0x1611F, 0x16129, 0x1611F, 0x1611E, 0x16120, 0x1611E, 0x1611E, 0x1611F,
+		0x1611E, 0x16129, 0x1611F, 0x1611E, 0x1611E, 0x16120, 0x16D67, 0x16D67, 0x16D63, 0x16D67,
+		0x16D63, 0x16D67, 0x16D67, 0x1D157, 0x1D165, 0x1D158, 0x1D165, 0x1D158, 0x1D165, 0x1D16E,
+		0x1D158, 0x1D165, 0x1D16F, 0x1D158, 0x1D165, 0x1D170, 0x1D158, 0x1D165, 0x1D171, 0x1D158,
+		0x1D165, 0x1D172, 0x1D1B9, 0x1D165, 0x1D1BA, 0x1D165, 0x1D1B9, 0x1D165, 0x1D16E, 0x1D1BA,
+		0x1D165, 0x1D16E, 0x1D1B9, 0x1D165, 0x1D16F, 0x1D1BA, 0x1D165, 0x1D16F, 0x4E3D, 0x4E38,
+		0x4E41, 0x20122, 0x4F60, 0x4FAE, 0x4FBB, 0x5002, 0x507A, 0x5099, 0x50E7, 0x50CF,
+		0x349E, 0x2063A, 0x514D, 0x5154, 0x5164, 0x5177, 0x2051C, 0x34B9, 0x5167, 0x518D,
+		0x2054B, 0x5197, 0x51A4, 0x4ECC, 0x51AC, 0x51B5, 0x291DF, 0x51F5, 0x5203, 0x34DF,
+		0x523B, 0x5246, 0x5272, 0x5277, 0x3515, 0x52C7, 0x52C9, 0x52E4, 0x52FA, 0x5305,
+		0x5306, 0x5317, 0x5349, 0x5351, 0x535A, 0x5373, 0x537D, 0x537F, 0x537F, 0x537F,
+		0x20A2C, 0x7070, 0x53CA, 0x53DF, 0x20B63, 0x53EB, 0x53F1, 0x5406, 0x549E, 0x5438,
+		0x5448, 0x5468, 0x54A2, 0x54F6, 0x5510, 0x5553, 0x5563, 0x5584, 0x5584, 0x5599,
+		0x55AB, 0x55B3, 0x55C2, 0x5716, 0x5606, 0x5717, 0x5651, 0x5674, 0x5207, 0x58EE,
+		0x57CE, 0x57F4, 0x580D, 0x578B, 0x5832, 0x5831, 0x58AC, 0x214E4, 0x58F2, 0x58F7,
+		0x5906, 0x591A, 0x5922, 0x5962, 0x216A8, 0x216EA, 0x59EC, 0x5A1B, 0x5A27, 0x59D8,
+		0x5A66, 0x36EE, 0x36FC, 0x5B08, 0x5B3E, 0x5B3E, 0x219C8, 0x5BC3, 0x5BD8, 0x5BE7,
+		0x5BF3, 0x21B18, 0x5BFF, 0x5C06, 0x5F53, 0x5C22, 0x3781, 0x5C60, 0x5C6E, 0x5CC0,
+		0x5C8D, 0x21DE4, 0x5D43, 0x21DE6, 0x5D6E, 0x5D6B, 0x5D7C, 0x5DE1, 0x5DE2, 0x382F,
+		0x5DFD, 0x5E28, 0x5E3D, 0x5E69, 0x3862, 0x22183, 0x387C, 0x5EB0, 0x5EB3, 0x5EB6,
+		0x5ECA, 0x2A392, 0x5EFE, 0x22331, 0x22331, 0x8201, 0x5F22, 0x5F22, 0x38C7, 0x232B8,
+		0x261DA, 0x5F62, 0x5F6B, 0x38E3, 0x5F9A, 0x5FCD, 0x5FD7, 0x5FF9, 0x6081, 0x393A,
+		0x391C, 0x6094, 0x226D4, 0x60C7, 0x6148, 0x614C, 0x614E, 0x614C, 0x617A, 0x618E,
+		0x61B2, 0x61A4, 0x61AF, 0x61DE, 0x61F2, 0x61F6, 0x6210, 0x621B, 0x625D, 0x62B1,
+		0x62D4, 0x6350, 0x22B0C, 0x633D, 0x62FC, 0x6368, 0x6383, 0x63E4, 0x22BF1, 0x6422,
+		0x63C5, 0x63A9, 0x3A2E, 0x6469, 0x647E, 0x649D, 0x6477, 0x3A6C, 0x654F, 0x656C,
+		0x2300A, 0x65E3, 0x66F8, 0x6649, 0x3B19, 0x6691, 0x3B08, 0x3AE4, 0x5192, 0x5195,
+		0x6700, 0x669C, 0x80AD, 0x43D9, 0x6717, 0x671B, 0x6721, 0x675E, 0x6753, 0x233C3,
+		0x3B49, 0x67FA, 0x6785, 0x6852, 0x6885, 0x2346D, 0x688E, 0x681F, 0x6914, 0x3B9D,
+		0x6942, 0x69A3, 0x69EA, 0x6AA8, 0x236A3, 0x6ADB, 0x3C18, 0x6B21, 0x238A7, 0x6B54,
+		0x3C4E, 0x6B72, 0x6B9F, 0x6BBA, 0x6BBB, 0x23A8D, 0x21D0B, 0x23AFA, 0x6C4E, 0x23CBC,
+		0x6CBF, 0x6CCD, 0x6C67, 0x6D16, 0x6D3E, 0x6D77, 0x6D41, 0x6D69, 0x6D78, 0x6D85,
+		0x23D1E, 0x6D34, 0x6E2F, 0x6E6E, 0x3D33, 0x6ECB, 0x6EC7, 0x23ED1, 0x6DF9, 0x6F6E,
+		0x23F5E, 0x23F8E, 0x6FC6, 0x7039, 0x701E, 0x701B, 0x3D96, 0x704A, 0x707D, 0x7077,
+		0x70AD, 0x20525, 0x7145, 0x24263, 0x719C, 0x243AB, 0x7228, 0x7235, 0x7250, 0x24608,
+		0x7280, 0x7295, 0x24735, 0x24814, 0x737A, 0x738B, 0x3EAC, 0x73A5, 0x3EB8, 0x3EB8,
+		0x7447, 0x745C, 0x7471, 0x7485, 0x74CA, 0x3F1B, 0x7524, 0x24C36, 0x753E, 0x24C92,
+		0x7570, 0x2219F, 0x7610, 0x24FA1, 0x24FB8, 0x25044, 0x3FFC, 0x4008, 0x76F4, 0x250F3,
+		0x250F2, 0x25119, 0x25133, 0x771E, 0x771F, 0x771F, 0x774A, 0x4039, 0x778B, 0x4046,
+		0x4096, 0x2541D, 0x784E, 0x788C, 0x78CC, 0x40E3, 0x25626, 0x7956, 0x2569A, 0x256C5,
+		0x798F, 0x79EB, 0x412F, 0x7A40, 0x7A4A, 0x7A4F, 0x2597C, 0x25AA7, 0x25AA7, 0x7AEE,
+		0x4202, 0x25BAB, 0x7BC6, 0x7BC9, 0x4227, 0x25C80, 0x7CD2, 0x42A0, 0x7CE8, 0x7CE3,
+		0x7D00, 0x25F86, 0x7D63, 0x4301, 0x7DC7, 0x7E02, 0x7E45, 0x4334, 0x26228, 0x26247,
+		0x4359, 0x262D9, 0x7F7A, 0x2633E, 0x7F95, 0x7FFA, 0x8005, 0x264DA, 0x26523, 0x8060,
+		0x265A8, 0x8070, 0x2335F, 0x43D5, 0x80B2, 0x8103, 0x440B, 0x813E, 0x5AB5, 0x267A7,
+		0x267B5, 0x23393, 0x2339C, 0x8201, 0x8204, 0x8F9E, 0x446B, 0x8291, 0x828B, 0x829D,
+		0x52B3, 0x82B1, 0x82B3, 0x82BD, 0x82E6, 0x26B3C, 0x82E5, 0x831D, 0x8363, 0x83AD,
+		0x8323, 0x83BD, 0x83E7, 0x8457, 0x8353, 0x83CA, 0x83CC, 0x83DC, 0x26C36, 0x26D6B,
+		0x26CD5, 0x452B, 0x84F1, 0x84F3, 0x8516, 0x273CA, 0x8564, 0x26F2C, 0x455D, 0x4561,
+		0x26FB1, 0x270D2, 0x456B, 0x8650, 0x865C, 0x8667, 0x8669, 0x86A9, 0x8688, 0x870E,
+		0x86E2, 0x8779, 0x8728, 0x876B, 0x8786, 0x45D7, 0x87E1, 0x8801, 0x45F9, 0x8860,
+		0x8863, 0x27667, 0x88D7, 0x88DE, 0x4635, 0x88FA, 0x34BB, 0x278AE, 0x27966, 0x46BE,
+		0x46C7, 0x8AA0, 0x8AED, 0x8B8A, 0x8C55, 0x27CA8, 0x8CAB, 0x8CC1, 0x8D1B, 0x8D77,
+		0x27F2F, 0x20804, 0x8DCB, 0x8DBC, 0x8DF0, 0x208DE, 0x8ED4, 0x8F38, 0x285D2, 0x285ED,
+		0x9094, 0x90F1, 0x9111, 0x2872E, 0x911B, 0x9238, 0x92D7, 0x92D8, 0x927C, 0x93F9,
+		0x9415, 0x28BFA, 0x958B, 0x4995, 0x95B7, 0x28D77, 0x49E6, 0x96C3, 0x5DB2, 0x9723,
+		0x29145, 0x2921A, 0x4A6E, 0x4A76, 0x97E0, 0x2940A, 0x4AB2, 0x29496, 0x980B, 0x980B,
+		0x9829, 0x295B6, 0x98E2, 0x4B33, 0x9929, 0x99A7, 0x99C2, 0x99FE, 0x4BCE, 0x29B30,
+		0x9B12, 0x9C40, 0x9CFD, 0x4CCE, 0x4CED, 0x9D67, 0x2A0CE, 0x4CF8, 0x2A105, 0x2A20E,
+		0x2A291, 0x9EBB, 0x4D56, 0x9EF9, 0x9EFE, 0x9F05, 0x9F0F, 0x9F16, 0x9F3B, 0x2A600,
+	},
+}
+
+// foldings is the case folding of CaseFolding.txt, statuses C and F.
+var foldings = mapping{
+	keys: []rune{
+		0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A,
+		0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054,
+		0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x00B5, 0x00C0, 0x00C1, 0x00C2,
+		0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC,
+		0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6,
+		0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x0100, 0x0102,
+		0x0104, 0x0106, 0x0108, 0x010A, 0x010C, 0x010E, 0x0110, 0x0112, 0x0114, 0x0116,
+		0x0118, 0x011A, 0x011C, 0x011E, 0x0120, 0x0122, 0x0124, 0x0126, 0x0128, 0x012A,
+		0x012C, 0x012E, 0x0130, 0x0132, 0x0134, 0x0136, 0x0139, 0x013B, 0x013D, 0x013F,
+		0x0141, 0x0143, 0x0145, 0x0147, 0x0149, 0x014A, 0x014C, 0x014E, 0x0150, 0x0152,
+		0x0154, 0x0156, 0x0158, 0x015A, 0x015C, 0x015E, 0x0160, 0x0162, 0x0164, 0x0166,
+		0x0168, 0x016A, 0x016C, 0x016E, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179,
+		0x017B, 0x017D, 0x017F, 0x0181, 0x0182, 0x0184, 0x0186, 0x0187, 0x0189, 0x018A,
+		0x018B, 0x018E, 0x018F, 0x0190, 0x0191, 0x0193, 0x0194, 0x0196, 0x0197, 0x0198,
+		0x019C, 0x019D, 0x019F, 0x01A0, 0x01A2, 0x01A4, 0x01A6, 0x01A7, 0x01A9, 0x01AC,
+		0x01AE, 0x01AF, 0x01B1, 0x01B2, 0x01B3, 0x01B5, 0x01B7, 0x01B8, 0x01BC, 0x01C4,
+		0x01C5, 0x01C7, 0x01C8, 0x01CA, 0x01CB, 0x01CD, 0x01CF, 0x01D1, 0x01D3, 0x01D5,
+		0x01D7, 0x01D9, 0x01DB, 0x01DE, 0x01E0, 0x01E2, 0x01E4, 0x01E6, 0x01E8, 0x01EA,
+		0x01EC, 0x01EE, 0x01F0, 0x01F1, 0x01F2, 0x01F4, 0x01F6, 0x01F7, 0x01F8, 0x01FA,
+		0x01FC, 0x01FE, 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020A, 0x020C, 0x020E,
+		0x0210, 0x0212, 0x0214, 0x0216, 0x0218, 0x021A, 0x021C, 0x021E, 0x0220, 0x0222,
+		0x0224, 0x0226, 0x0228, 0x022A, 0x022C, 0x022E, 0x0230, 0x0232, 0x023A, 0x023B,
+		0x023D, 0x023E, 0x0241, 0x0243, 0x0244, 0x0245, 0x0246, 0x0248, 0x024A, 0x024C,
+		0x024E, 0x0345, 0x0370, 0x0372, 0x0376, 0x037F, 0x0386, 0x0388, 0x0389, 0x038A,
+		0x038C, 0x038E, 0x038F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
+		0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
+		0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03AA, 0x03AB,
+		0x03B0, 0x03C2, 0x03CF, 0x03D0, 0x03D1, 0x03D5, 0x03D6, 0x03D8, 0x03DA, 0x03DC,
+		0x03DE, 0x03E0, 0x03E2, 0x03E4, 0x03E6, 0x03E8, 0x03EA, 0x03EC, 0x03EE, 0x03F0,
+		0x03F1, 0x03F4, 0x03F5, 0x03F7, 0x03F9, 0x03FA, 0x03FD, 0x03FE, 0x03FF, 0x0400,
+		0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 0x0408, 0x0409, 0x040A,
+		0x040B, 0x040C, 0x040D, 0x040E, 0x040F, 0x0410, 0x0411, 0x0412, 0x0413, 0x0414,
+		0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
+		0x041F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428,
+		0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 0x0460, 0x0462, 0x0464,
+		0x0466, 0x0468, 0x046A, 0x046C, 0x046E, 0x0470, 0x0472, 0x0474, 0x0476, 0x0478,
+		0x047A, 0x047C, 0x047E, 0x0480, 0x048A, 0x048C, 0x048E, 0x0490, 0x0492, 0x0494,
+		0x0496, 0x0498, 0x049A, 0x049C, 0x049E, 0x04A0, 0x04A2, 0x04A4, 0x04A6, 0x04A8,
+		0x04AA, 0x04AC, 0x04AE, 0x04B0, 0x04B2, 0x04B4, 0x04B6, 0x04B8, 0x04BA, 0x04BC,
+		0x04BE, 0x04C0, 0x04C1, 0x04C3, 0x04C5, 0x04C7, 0x04C9, 0x04CB, 0x04CD, 0x04D0,
+		0x04D2, 0x04D4, 0x04D6, 0x04D8, 0x04DA, 0x04DC, 0x04DE, 0x04E0, 0x04E2, 0x04E4,
+		0x04E6, 0x04E8, 0x04EA, 0x04EC, 0x04EE, 0x04F0, 0x04F2, 0x04F4, 0x04F6, 0x04F8,
+		0x04FA, 0x04FC, 0x04FE, 0x0500, 0x0502, 0x0504, 0x0506, 0x0508, 0x050A, 0x050C,
+		0x050E, 0x0510, 0x0512, 0x0514, 0x0516, 0x0518, 0x051A, 0x051C, 0x051E, 0x0520,
+		0x0522, 0x0524, 0x0526, 0x0528, 0x052A, 0x052C, 0x052E, 0x0531, 0x0532, 0x0533,
+		0x0534, 0x0535, 0x0536, 0x0537, 0x0538, 0x0539, 0x053A, 0x053B, 0x053C, 0x053D,
+		0x053E, 0x053F, 0x0540, 0x0541, 0x0542, 0x0543, 0x0544, 0x0545, 0x0546, 0x0547,
+		0x0548, 0x0549, 0x054A, 0x054B, 0x054C, 0x054D, 0x054E, 0x054F, 0x0550, 0x0551,
+		0x0552, 0x0553, 0x0554, 0x0555, 0x0556, 0x0587, 0x10A0, 0x10A1, 0x10A2, 0x10A3,
+		0x10A4, 0x10A5, 0x10A6, 0x10A7, 0x10A8, 0x10A9, 0x10AA, 0x10AB, 0x10AC, 0x10AD,
+		0x10AE, 0x10AF, 0x10B0, 0x10B1, 0x10B2, 0x10B3, 0x10B4, 0x10B5, 0x10B6, 0x10B7,
+		0x10B8, 0x10B9, 0x10BA, 0x10BB, 0x10BC, 0x10BD, 0x10BE, 0x10BF, 0x10C0, 0x10C1,
+		0x10C2, 0x10C3, 0x10C4, 0x10C5, 0x10C7, 0x10CD, 0x13F8, 0x13F9, 0x13FA, 0x13FB,
+		0x13FC, 0x13FD, 0x1C80, 0x1C81, 0x1C82, 0x1C83, 0x1C84, 0x1C85, 0x1C86, 0x1C87,
+		0x1C88, 0x1C89, 0x1C90, 0x1C91, 0x1C92, 0x1C93, 0x1C94, 0x1C95, 0x1C96, 0x1C97,
+		0x1C98, 0x1C99, 0x1C9A, 0x1C9B, 0x1C9C, 0x1C9D, 0x1C9E, 0x1C9F, 0x1CA0, 0x1CA1,
+		0x1CA2, 0x1CA3, 0x1CA4, 0x1CA5, 0x1CA6, 0x1CA7, 0x1CA8, 0x1CA9, 0x1CAA, 0x1CAB,
+		0x1CAC, 0x1CAD, 0x1CAE, 0x1CAF, 0x1CB0, 0x1CB1, 0x1CB2, 0x1CB3, 0x1CB4, 0x1CB5,
+		0x1CB6, 0x1CB7, 0x1CB8, 0x1CB9, 0x1CBA, 0x1CBD, 0x1CBE, 0x1CBF, 0x1E00, 0x1E02,
+		0x1E04, 0x1E06, 0x1E08, 0x1E0A, 0x1E0C, 0x1E0E, 0x1E10, 0x1E12, 0x1E14, 0x1E16,
+		0x1E18, 0x1E1A, 0x1E1C, 0x1E1E, 0x1E20, 0x1E22, 0x1E24, 0x1E26, 0x1E28, 0x1E2A,
+		0x1E2C, 0x1E2E, 0x1E30, 0x1E32, 0x1E34, 0x1E36, 0x1E38, 0x1E3A, 0x1E3C, 0x1E3E,
+		0x1E40, 0x1E42, 0x1E44, 0x1E46, 0x1E48, 0x1E4A, 0x1E4C, 0x1E4E, 0x1E50, 0x1E52,
+		0x1E54, 0x1E56, 0x1E58, 0x1E5A, 0x1E5C, 0x1E5E, 0x1E60, 0x1E62, 0x1E64, 0x1E66,
+		0x1E68, 0x1E6A, 0x1E6C, 0x1E6E, 0x1E70, 0x1E72, 0x1E74, 0x1E76, 0x1E78, 0x1E7A,
+		0x1E7C, 0x1E7E, 0x1E80, 0x1E82, 0x1E84, 0x1E86, 0x1E88, 0x1E8A, 0x1E8C, 0x1E8E,
+		0x1E90, 0x1E92, 0x1E94, 0x1E96, 0x1E97, 0x1E98, 0x1E99, 0x1E9A, 0x1E9B, 0x1E9E,
+		0x1EA0, 0x1EA2, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAA, 0x1EAC, 0x1EAE, 0x1EB0, 0x1EB2,
+		0x1EB4, 0x1EB6, 0x1EB8, 0x1EBA, 0x1EBC, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6,
+		0x1EC8, 0x1ECA, 0x1ECC, 0x1ECE, 0x1ED0, 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EDA,
+		0x1EDC, 0x1EDE, 0x1EE0, 0x1EE2, 0x1EE4, 0x1EE6, 0x1EE8, 0x1EEA, 0x1EEC, 0x1EEE,
+		0x1EF0, 0x1EF2, 0x1EF4, 0x1EF6, 0x1EF8, 0x1EFA, 0x1EFC, 0x1EFE, 0x1F08, 0x1F09,
+		0x1F0A, 0x1F0B, 0x1F0C, 0x1F0D, 0x1F0E, 0x1F0F, 0x1F18, 0x1F19, 0x1F1A, 0x1F1B,
+		0x1F1C, 0x1F1D, 0x1F28, 0x1F29, 0x1F2A, 0x1F2B, 0x1F2C, 0x1F2D, 0x1F2E, 0x1F2F,
+		0x1F38, 0x1F39, 0x1F3A, 0x1F3B, 0x1F3C, 0x1F3D, 0x1F3E, 0x1F3F, 0x1F48, 0x1F49,
+		0x1F4A, 0x1F4B, 0x1F4C, 0x1F4D, 0x1F50, 0x1F52, 0x1F54, 0x1F56, 0x1F59, 0x1F5B,
+		0x1F5D, 0x1F5F, 0x1F68, 0x1F69, 0x1F6A, 0x1F6B, 0x1F6C, 0x1F6D, 0x1F6E, 0x1F6F,
+		0x1F80, 0x1F81, 0x1F82, 0x1F83, 0x1F84, 0x1F85, 0x1F86, 0x1F87, 0x1F88, 0x1F89,
+		0x1F8A, 0x1F8B, 0x1F8C, 0x1F8D, 0x1F8E, 0x1F8F, 0x1F90, 0x1F91, 0x1F92, 0x1F93,
+		0x1F94, 0x1F95, 0x1F96, 0x1F97, 0x1F98, 0x1F99, 0x1F9A, 0x1F9B, 0x1F9C, 0x1F9D,
+		0x1F9E, 0x1F9F, 0x1FA0, 0x1FA1, 0x1FA2, 0x1FA3, 0x1FA4, 0x1FA5, 0x1FA6, 0x1FA7,
+		0x1FA8, 0x1FA9, 0x1FAA, 0x1FAB, 0x1FAC, 0x1FAD, 0x1FAE, 0x1FAF, 0x1FB2, 0x1FB3,
+		0x1FB4, 0x1FB6, 0x1FB7, 0x1FB8, 0x1FB9, 0x1FBA, 0x1FBB, 0x1FBC, 0x1FBE, 0x1FC2,
+		0x1FC3, 0x1FC4, 0x1FC6, 0x1FC7, 0x1FC8, 0x1FC9, 0x1FCA, 0x1FCB, 0x1FCC, 0x1FD2,
+		0x1FD3, 0x1FD6, 0x1FD7, 0x1FD8, 0x1FD9, 0x1FDA, 0x1FDB, 0x1FE2, 0x1FE3, 0x1FE4,
+		0x1FE6, 0x1FE7, 0x1FE8, 0x1FE9, 0x1FEA, 0x1FEB, 0x1FEC, 0x1FF2, 0x1FF3, 0x1FF4,
+		0x1FF6, 0x1FF7, 0x1FF8, 0x1FF9, 0x1FFA, 0x1FFB, 0x1FFC, 0x2126, 0x212A, 0x212B,
+		0x2132, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166, 0x2167, 0x2168,
+		0x2169, 0x216A, 0x216B, 0x216C, 0x216D, 0x216E, 0x216F, 0x2183, 0x24B6, 0x24B7,
+		0x24B8, 0x24B9, 0x24BA, 0x24BB, 0x24BC, 0x24BD, 0x24BE, 0x24BF, 0x24C0, 0x24C1,
+		0x24C2, 0x24C3, 0x24C4, 0x24C5, 0x24C6, 0x24C7, 0x24C8, 0x24C9, 0x24CA, 0x24CB,
+		0x24CC, 0x24CD, 0x24CE, 0x24CF, 0x2C00, 0x2C01, 0x2C02, 0x2C03, 0x2C04, 0x2C05,
+		0x2C06, 0x2C07, 0x2C08, 0x2C09, 0x2C0A, 0x2C0B, 0x2C0C, 0x2C0D, 0x2C0E, 0x2C0F,
+		0x2C10, 0x2C11, 0x2C12, 0x2C13, 0x2C14, 0x2C15, 0x2C16, 0x2C17, 0x2C18, 0x2C19,
+		0x2C1A, 0x2C1B, 0x2C1C, 0x2C1D, 0x2C1E, 0x2C1F, 0x2C20, 0x2C21, 0x2C22, 0x2C23,
+		0x2C24, 0x2C25, 0x2C26, 0x2C27, 0x2C28, 0x2C29, 0x2C2A, 0x2C2B, 0x2C2C, 0x2C2D,
+		0x2C2E, 0x2C2F, 0x2C60, 0x2C62, 0x2C63, 0x2C64, 0x2C67, 0x2C69, 0x2C6B, 0x2C6D,
+		0x2C6E, 0x2C6F, 0x2C70, 0x2C72, 0x2C75, 0x2C7E, 0x2C7F, 0x2C80, 0x2C82, 0x2C84,
+		0x2C86, 0x2C88, 0x2C8A, 0x2C8C, 0x2C8E, 0x2C90, 0x2C92, 0x2C94, 0x2C96, 0x2C98,
+		0x2C9A, 0x2C9C, 0x2C9E, 0x2CA0, 0x2CA2, 0x2CA4, 0x2CA6, 0x2CA8, 0x2CAA, 0x2CAC,
+		0x2CAE, 0x2CB0, 0x2CB2, 0x2CB4, 0x2CB6, 0x2CB8, 0x2CBA, 0x2CBC, 0x2CBE, 0x2CC0,
+		0x2CC2, 0x2CC4, 0x2CC6, 0x2CC8, 0x2CCA, 0x2CCC, 0x2CCE, 0x2CD0, 0x2CD2, 0x2CD4,
+		0x2CD6, 0x2CD8, 0x2CDA, 0x2CDC, 0x2CDE, 0x2CE0, 0x2CE2, 0x2CEB, 0x2CED, 0x2CF2,
+		0xA640, 0xA642, 0xA644, 0xA646, 0xA648, 0xA64A, 0xA64C, 0xA64E, 0xA650, 0xA652,
+		0xA654, 0xA656, 0xA658, 0xA65A, 0xA65C, 0xA65E, 0xA660, 0xA662, 0xA664, 0xA666,
+		0xA668, 0xA66A, 0xA66C, 0xA680, 0xA682, 0xA684, 0xA686, 0xA688, 0xA68A, 0xA68C,
+		0xA68E, 0xA690, 0xA692, 0xA694, 0xA696, 0xA698, 0xA69A, 0xA722, 0xA724, 0xA726,
+		0xA728, 0xA72A, 0xA72C, 0xA72E, 0xA732, 0xA734, 0xA736, 0xA738, 0xA73A, 0xA73C,
+		0xA73E, 0xA740, 0xA742, 0xA744, 0xA746, 0xA748, 0xA74A, 0xA74C, 0xA74E, 0xA750,
+		0xA752, 0xA754, 0xA756, 0xA758, 0xA75A, 0xA75C, 0xA75E, 0xA760, 0xA762, 0xA764,
+		0xA766, 0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA77D, 0xA77E, 0xA780,
+		0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798, 0xA79A,
+		0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7AA, 0xA7AB, 0xA7AC,
+		0xA7AD, 0xA7AE, 0xA7B0, 0xA7B1, 0xA7B2, 0xA7B3, 0xA7B4, 0xA7B6, 0xA7B8, 0xA7BA,
+		0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C4, 0xA7C5, 0xA7C6, 0xA7C7, 0xA7C9, 0xA7CB,
+		0xA7CC, 0xA7CE, 0xA7D0, 0xA7D2, 0xA7D4, 0xA7D6, 0xA7D8, 0xA7DA, 0xA7DC, 0xA7DD,
+		0xA7E2, 0xA7F5, 0xAB6C, 0xAB6D, 0xAB70, 0xAB71, 0xAB72, 0xAB73, 0xAB74, 0xAB75,
+		0xAB76, 0xAB77, 0xAB78, 0xAB79, 0xAB7A, 0xAB7B, 0xAB7C, 0xAB7D, 0xAB7E, 0xAB7F,
+		0xAB80, 0xAB81, 0xAB82, 0xAB83, 0xAB84, 0xAB85, 0xAB86, 0xAB87, 0xAB88, 0xAB89,
+		0xAB8A, 0xAB8B, 0xAB8C, 0xAB8D, 0xAB8E, 0xAB8F, 0xAB90, 0xAB91, 0xAB92, 0xAB93,
+		0xAB94, 0xAB95, 0xAB96, 0xAB97, 0xAB98, 0xAB99, 0xAB9A, 0xAB9B, 0xAB9C, 0xAB9D,
+		0xAB9E, 0xAB9F, 0xABA0, 0xABA1, 0xABA2, 0xABA3, 0xABA4, 0xABA5, 0xABA6, 0xABA7,
+		0xABA8, 0xABA9, 0xABAA, 0xABAB, 0xABAC, 0xABAD, 0xABAE, 0xABAF, 0xABB0, 0xABB1,
+		0xABB2, 0xABB3, 0xABB4, 0xABB5, 0xABB6, 0xABB7, 0xABB8, 0xABB9, 0xABBA, 0xABBB,
+		0xABBC, 0xABBD, 0xABBE, 0xABBF, 0xFB00, 0xFB01, 0xFB02, 0xFB03, 0xFB04, 0xFB05,
+		0xFB06, 0xFB13, 0xFB14, 0xFB15, 0xFB16, 0xFB17, 0xFF21, 0xFF22, 0xFF23, 0xFF24,
+		0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E,
+		0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38,
+		0xFF39, 0xFF3A, 0x10400, 0x10401, 0x10402, 0x10403, 0x10404, 0x10405, 0x10406, 0x10407,
+		0x10408, 0x10409, 0x1040A, 0x1040B, 0x1040C, 0x1040D, 0x1040E, 0x1040F, 0x10410, 0x10411,
+		0x10412, 0x10413, 0x10414, 0x10415, 0x10416, 0x10417, 0x10418, 0x10419, 0x1041A, 0x1041B,
+		0x1041C, 0x1041D, 0x1041E, 0x1041F, 0x10420, 0x10421, 0x10422, 0x10423, 0x10424, 0x10425,
+		0x10426, 0x10427, 0x104B0, 0x104B1, 0x104B2, 0x104B3, 0x104B4, 0x104B5, 0x104B6, 0x104B7,
+		0x104B8, 0x104B9, 0x104BA, 0x104BB, 0x104BC, 0x104BD, 0x104BE, 0x104BF, 0x104C0, 0x104C1,
+		0x104C2, 0x104C3, 0x104C4, 0x104C5, 0x104C6, 0x104C7, 0x104C8, 0x104C9, 0x104CA, 0x104CB,
+		0x104CC, 0x104CD, 0x104CE, 0x104CF, 0x104D0, 0x104D1, 0x104D2, 0x104D3, 0x10570, 0x10571,
+		0x10572, 0x10573, 0x10574, 0x10575, 0x10576, 0x10577, 0x10578, 0x10579, 0x1057A, 0x1057C,
+		0x1057D, 0x1057E, 0x1057F, 0x10580, 0x10581, 0x10582, 0x10583, 0x10584, 0x10585, 0x10586,
+		0x10587, 0x10588, 0x10589, 0x1058A, 0x1058C, 0x1058D, 0x1058E, 0x1058F, 0x10590, 0x10591,
+		0x10592, 0x10594, 0x10595, 0x10C80, 0x10C81, 0x10C82, 0x10C83, 0x10C84, 0x10C85, 0x10C86,
+		0x10C87, 0x10C88, 0x10C89, 0x10C8A, 0x10C8B, 0x10C8C, 0x10C8D, 0x10C8E, 0x10C8F, 0x10C90,
+		0x10C91, 0x10C92, 0x10C93, 0x10C94, 0x10C95, 0x10C96, 0x10C97, 0x10C98, 0x10C99, 0x10C9A,
+		0x10C9B, 0x10C9C, 0x10C9D, 0x10C9E, 0x10C9F, 0x10CA0, 0x10CA1, 0x10CA2, 0x10CA3, 0x10CA4,
+		0x10CA5, 0x10CA6, 0x10CA7, 0x10CA8, 0x10CA9, 0x10CAA, 0x10CAB, 0x10CAC, 0x10CAD, 0x10CAE,
+		0x10CAF, 0x10CB0, 0x10CB1, 0x10CB2, 0x10D50, 0x10D51, 0x10D52, 0x10D53, 0x10D54, 0x10D55,
+		0x10D56, 0x10D57, 0x10D58, 0x10D59, 0x10D5A, 0x10D5B, 0x10D5C, 0x10D5D, 0x10D5E, 0x10D5F,
+		0x10D60, 0x10D61, 0x10D62, 0x10D63, 0x10D64, 0x10D65, 0x118A0, 0x118A1, 0x118A2, 0x118A3,
+		0x118A4, 0x118A5, 0x118A6, 0x118A7, 0x118A8, 0x118A9, 0x118AA, 0x118AB, 0x118AC, 0x118AD,
+		0x118AE, 0x118AF, 0x118B0, 0x118B1, 0x118B2, 0x118B3, 0x118B4, 0x118B5, 0x118B6, 0x118B7,
+		0x118B8, 0x118B9, 0x118BA, 0x118BB, 0x118BC, 0x118BD, 0x118BE, 0x118BF, 0x16E40, 0x16E41,
+		0x16E42, 0x16E43, 0x16E44, 0x16E45, 0x16E46, 0x16E47, 0x16E48, 0x16E49, 0x16E4A, 0x16E4B,
+		0x16E4C, 0x16E4D, 0x16E4E, 0x16E4F, 0x16E50, 0x16E51, 0x16E52, 0x16E53, 0x16E54, 0x16E55,
+		0x16E56, 0x16E57, 0x16E58, 0x16E59, 0x16E5A, 0x16E5B, 0x16E5C, 0x16E5D, 0x16E5E, 0x16E5F,
+		0x16EA0, 0x16EA1, 0x16EA2, 0x16EA3, 0x16EA4, 0x16EA5, 0x16EA6, 0x16EA7, 0x16EA8, 0x16EA9,
+		0x16EAA, 0x16EAB, 0x16EAC, 0x16EAD, 0x16EAE, 0x16EAF, 0x16EB0, 0x16EB1, 0x16EB2, 0x16EB3,
+		0x16EB4, 0x16EB5, 0x16EB6, 0x16EB7, 0x16EB8, 0x1DF40, 0x1DF48, 0x1DF4A, 0x1DF4D, 0x1DF51,
+		0x1DF68, 0x1DF6A, 0x1DF6C, 0x1DF6E, 0x1DF72, 0x1DF74, 0x1DF76, 0x1DF78, 0x1DF7A, 0x1DF7C,
+		0x1DF7E, 0x1DF95, 0x1E900, 0x1E901, 0x1E902, 0x1E903, 0x1E904, 0x1E905, 0x1E906, 0x1E907,
+		0x1E908, 0x1E909, 0x1E90A, 0x1E90B, 0x1E90C, 0x1E90D, 0x1E90E, 0x1E90F, 0x1E910, 0x1E911,
+		0x1E912, 0x1E913, 0x1E914, 0x1E915, 0x1E916, 0x1E917, 0x1E918, 0x1E919, 0x1E91A, 0x1E91B,
+		0x1E91C, 0x1E91D, 0x1E91E, 0x1E91F, 0x1E920, 0x1E921,
+	},
+	start: []uint16{
+		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+		12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+		24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+		36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 59, 60,
+		61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 85,
+		86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 98,
+		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
+		111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
+		123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+		135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146,
+		147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
+		159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
+		171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
+		183, 184, 185, 187, 188, 189, 190, 191, 192, 193, 194, 195,
+		196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+		208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
+		220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
+		232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
+		244, 245, 246, 247, 250, 251, 252, 253, 254, 255, 256, 257,
+		258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
+		270, 271, 272, 273, 274, 275, 276, 279, 280, 281, 282, 283,
+		284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
+		296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
+		308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319,
+		320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331,
+		332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343,
+		344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355,
+		356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367,
+		368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379,
+		380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391,
+		392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403,
+		404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415,
+		416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427,
+		428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439,
+		440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451,
+		452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463,
+		464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475,
+		476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487,
+		488, 489, 490, 491, 492, 493, 495, 496, 497, 498, 499, 500,
+		501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
+		513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524,
+		525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536,
+		537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548,
+		549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
+		561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572,
+		573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584,
+		585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596,
+		597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
+		609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620,
+		621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632,
+		633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644,
+		645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
+		657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668,
+		669, 670, 671, 672, 674, 676, 678, 680, 682, 683, 685, 686,
+		687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698,
+		699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710,
+		711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722,
+		723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734,
+		735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746,
+		747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758,
+		759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 771,
+		774, 777, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789,
+		790, 791, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810,
+		812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834,
+		836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858,
+		860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882,
+		884, 886, 888, 890, 892, 894, 896, 899, 900, 901, 902, 903,
+		905, 906, 908, 910, 912, 914, 917, 918, 919, 920, 921, 923,
+		926, 929, 931, 934, 935, 936, 937, 938, 941, 944, 946, 948,
+		951, 952, 953, 954, 955, 956, 958, 960, 962, 964, 967, 968,
+		969, 970, 971, 973, 974, 975, 976, 977, 978, 979, 980, 981,
+		982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993,
+		994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005,
+		1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
+		1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029,
+		1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041,
+		1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053,
+		1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
+		1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077,
+		1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089,
+		1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101,
+		1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
+		1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125,
+		1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137,
+		1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149,
+		1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
+		1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173,
+		1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185,
+		1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197,
+		1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,
+		1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221,
+		1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233,
+		1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245,
+		1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
+		1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269,
+		1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,
+		1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293,
+		1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,
+		1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317,
+		1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329,
+		1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341,
+		1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1352, 1354, 1356,
+		1359, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1377, 1378, 1379,
+		1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391,
+		1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403,
+		1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415,
+		1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427,
+		1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439,
+		1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451,
+		1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463,
+		1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475,
+		1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487,
+		1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499,
+		1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511,
+		1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523,
+		1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535,
+		1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547,
+		1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559,
+		1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571,
+		1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583,
+		1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595,
+		1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607,
+		1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619,
+		1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631,
+		1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643,
+		1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655,
+		1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667,
+		1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679,
+		1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690, 1691,
+		1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704,
+		1705, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716,
+		1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727,
+	},
+	data: []rune{
+		0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A,
+		0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074,
+		0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x03BC, 0x00E0, 0x00E1, 0x00E2,
+		0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC,
+		0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6,
+		0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0073, 0x0073, 0x0101,
+		0x0103, 0x0105, 0x0107, 0x0109, 0x010B, 0x010D, 0x010F, 0x0111, 0x0113, 0x0115,
+		0x0117, 0x0119, 0x011B, 0x011D, 0x011F, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129,
+		0x012B, 0x012D, 0x012F, 0x0069, 0x0307, 0x0133, 0x0135, 0x0137, 0x013A, 0x013C,
+		0x013E, 0x0140, 0x0142, 0x0144, 0x0146, 0x0148, 0x02BC, 0x006E, 0x014B, 0x014D,
+		0x014F, 0x0151, 0x0153, 0x0155, 0x0157, 0x0159, 0x015B, 0x015D, 0x015F, 0x0161,
+		0x0163, 0x0165, 0x0167, 0x0169, 0x016B, 0x016D, 0x016F, 0x0171, 0x0173, 0x0175,
+		0x0177, 0x00FF, 0x017A, 0x017C, 0x017E, 0x0073, 0x0253, 0x0183, 0x0185, 0x0254,
+		0x0188, 0x0256, 0x0257, 0x018C, 0x01DD, 0x0259, 0x025B, 0x0192, 0x0260, 0x0263,
+		0x0269, 0x0268, 0x0199, 0x026F, 0x0272, 0x0275, 0x01A1, 0x01A3, 0x01A5, 0x0280,
+		0x01A8, 0x0283, 0x01AD, 0x0288, 0x01B0, 0x028A, 0x028B, 0x01B4, 0x01B6, 0x0292,
+		0x01B9, 0x01BD, 0x01C6, 0x01C6, 0x01C9, 0x01C9, 0x01CC, 0x01CC, 0x01CE, 0x01D0,
+		0x01D2, 0x01D4, 0x01D6, 0x01D8, 0x01DA, 0x01DC, 0x01DF, 0x01E1, 0x01E3, 0x01E5,
+		0x01E7, 0x01E9, 0x01EB, 0x01ED, 0x01EF, 0x006A, 0x030C, 0x01F3, 0x01F3, 0x01F5,
+		0x0195, 0x01BF, 0x01F9, 0x01FB, 0x01FD, 0x01FF, 0x0201, 0x0203, 0x0205, 0x0207,
+		0x0209, 0x020B, 0x020D, 0x020F, 0x0211, 0x0213, 0x0215, 0x0217, 0x0219, 0x021B,
+		0x021D, 0x021F, 0x019E, 0x0223, 0x0225, 0x0227, 0x0229, 0x022B, 0x022D, 0x022F,
+		0x0231, 0x0233, 0x2C65, 0x023C, 0x019A, 0x2C66, 0x0242, 0x0180, 0x0289, 0x028C,
+		0x0247, 0x0249, 0x024B, 0x024D, 0x024F, 0x03B9, 0x0371, 0x0373, 0x0377, 0x03F3,
+		0x03AC, 0x03AD, 0x03AE, 0x03AF, 0x03CC, 0x03CD, 0x03CE, 0x03B9, 0x0308, 0x0301,
+		0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA,
+		0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3, 0x03C4, 0x03C5,
+		0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03C5, 0x0308, 0x0301, 0x03C3,
+		0x03D7, 0x03B2, 0x03B8, 0x03C6, 0x03C0, 0x03D9, 0x03DB, 0x03DD, 0x03DF, 0x03E1,
+		0x03E3, 0x03E5, 0x03E7, 0x03E9, 0x03EB, 0x03ED, 0x03EF, 0x03BA, 0x03C1, 0x03B8,
+		0x03B5, 0x03F8, 0x03F2, 0x03FB, 0x037B, 0x037C, 0x037D, 0x0450, 0x0451, 0x0452,
+		0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, 0x045B, 0x045C,
+		0x045D, 0x045E, 0x045F, 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436,
+		0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0440,
+		0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A,
+		0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0x0461, 0x0463, 0x0465, 0x0467, 0x0469,
+		0x046B, 0x046D, 0x046F, 0x0471, 0x0473, 0x0475, 0x0477, 0x0479, 0x047B, 0x047D,
+		0x047F, 0x0481, 0x048B, 0x048D, 0x048F, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499,
+		0x049B, 0x049D, 0x049F, 0x04A1, 0x04A3, 0x04A5, 0x04A7, 0x04A9, 0x04AB, 0x04AD,
+		0x04AF, 0x04B1, 0x04B3, 0x04B5, 0x04B7, 0x04B9, 0x04BB, 0x04BD, 0x04BF, 0x04CF,
+		0x04C2, 0x04C4, 0x04C6, 0x04C8, 0x04CA, 0x04CC, 0x04CE, 0x04D1, 0x04D3, 0x04D5,
+		0x04D7, 0x04D9, 0x04DB, 0x04DD, 0x04DF, 0x04E1, 0x04E3, 0x04E5, 0x04E7, 0x04E9,
+		0x04EB, 0x04ED, 0x04EF, 0x04F1, 0x04F3, 0x04F5, 0x04F7, 0x04F9, 0x04FB, 0x04FD,
+		0x04FF, 0x0501, 0x0503, 0x0505, 0x0507, 0x0509, 0x050B, 0x050D, 0x050F, 0x0511,
+		0x0513, 0x0515, 0x0517, 0x0519, 0x051B, 0x051D, 0x051F, 0x0521, 0x0523, 0x0525,
+		0x0527, 0x0529, 0x052B, 0x052D, 0x052F, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565,
+		0x0566, 0x0567, 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F,
+		0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577, 0x0578, 0x0579,
+		0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F, 0x0580, 0x0581, 0x0582, 0x0583,
+		0x0584, 0x0585, 0x0586, 0x0565, 0x0582, 0x2D00, 0x2D01, 0x2D02, 0x2D03, 0x2D04,
+		0x2D05, 0x2D06, 0x2D07, 0x2D08, 0x2D09, 0x2D0A, 0x2D0B, 0x2D0C, 0x2D0D, 0x2D0E,
+		0x2D0F, 0x2D10, 0x2D11, 0x2D12, 0x2D13, 0x2D14, 0x2D15, 0x2D16, 0x2D17, 0x2D18,
+		0x2D19, 0x2D1A, 0x2D1B, 0x2D1C, 0x2D1D, 0x2D1E, 0x2D1F, 0x2D20, 0x2D21, 0x2D22,
+		0x2D23, 0x2D24, 0x2D25, 0x2D27, 0x2D2D, 0x13F0, 0x13F1, 0x13F2, 0x13F3, 0x13F4,
+		0x13F5, 0x0432, 0x0434, 0x043E, 0x0441, 0x0442, 0x0442, 0x044A, 0x0463, 0xA64B,
+		0x1C8A, 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7, 0x10D8,
+		0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF, 0x10E0, 0x10E1, 0x10E2,
+		0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7, 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC,
+		0x10ED, 0x10EE, 0x10EF, 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10F6,
+		0x10F7, 0x10F8, 0x10F9, 0x10FA, 0x10FD, 0x10FE, 0x10FF, 0x1E01, 0x1E03, 0x1E05,
+		0x1E07, 0x1E09, 0x1E0B, 0x1E0D, 0x1E0F, 0x1E11, 0x1E13, 0x1E15, 0x1E17, 0x1E19,
+		0x1E1B, 0x1E1D, 0x1E1F, 0x1E21, 0x1E23, 0x1E25, 0x1E27, 0x1E29, 0x1E2B, 0x1E2D,
+		0x1E2F, 0x1E31, 0x1E33, 0x1E35, 0x1E37, 0x1E39, 0x1E3B, 0x1E3D, 0x1E3F, 0x1E41,
+		0x1E43, 0x1E45, 0x1E47, 0x1E49, 0x1E4B, 0x1E4D, 0x1E4F, 0x1E51, 0x1E53, 0x1E55,
+		0x1E57, 0x1E59, 0x1E5B, 0x1E5D, 0x1E5F, 0x1E61, 0x1E63, 0x1E65, 0x1E67, 0x1E69,
+		0x1E6B, 0x1E6D, 0x1E6F, 0x1E71, 0x1E73, 0x1E75, 0x1E77, 0x1E79, 0x1E7B, 0x1E7D,
+		0x1E7F, 0x1E81, 0x1E83, 0x1E85, 0x1E87, 0x1E89, 0x1E8B, 0x1E8D, 0x1E8F, 0x1E91,
+		0x1E93, 0x1E95, 0x0068, 0x0331, 0x0074, 0x0308, 0x0077, 0x030A, 0x0079, 0x030A,
+		0x0061, 0x02BE, 0x1E61, 0x0073, 0x0073, 0x1EA1, 0x1EA3, 0x1EA5, 0x1EA7, 0x1EA9,
+		0x1EAB, 0x1EAD, 0x1EAF, 0x1EB1, 0x1EB3, 0x1EB5, 0x1EB7, 0x1EB9, 0x1EBB, 0x1EBD,
+		0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1EC9, 0x1ECB, 0x1ECD, 0x1ECF, 0x1ED1,
+		0x1ED3, 0x1ED5, 0x1ED7, 0x1ED9, 0x1EDB, 0x1EDD, 0x1EDF, 0x1EE1, 0x1EE3, 0x1EE5,
+		0x1EE7, 0x1EE9, 0x1EEB, 0x1EED, 0x1EEF, 0x1EF1, 0x1EF3, 0x1EF5, 0x1EF7, 0x1EF9,
+		0x1EFB, 0x1EFD, 0x1EFF, 0x1F00, 0x1F01, 0x1F02, 0x1F03, 0x1F04, 0x1F05, 0x1F06,
+		0x1F07, 0x1F10, 0x1F11, 0x1F12, 0x1F13, 0x1F14, 0x1F15, 0x1F20, 0x1F21, 0x1F22,
+		0x1F23, 0x1F24, 0x1F25, 0x1F26, 0x1F27, 0x1F30, 0x1F31, 0x1F32, 0x1F33, 0x1F34,
+		0x1F35, 0x1F36, 0x1F37, 0x1F40, 0x1F41, 0x1F42, 0x1F43, 0x1F44, 0x1F45, 0x03C5,
+		0x0313, 0x03C5, 0x0313, 0x0300, 0x03C5, 0x0313, 0x0301, 0x03C5, 0x0313, 0x0342,
+		0x1F51, 0x1F53, 0x1F55, 0x1F57, 0x1F60, 0x1F61, 0x1F62, 0x1F63, 0x1F64, 0x1F65,
+		0x1F66, 0x1F67, 0x1F00, 0x03B9, 0x1F01, 0x03B9, 0x1F02, 0x03B9, 0x1F03, 0x03B9,
+		0x1F04, 0x03B9, 0x1F05, 0x03B9, 0x1F06, 0x03B9, 0x1F07, 0x03B9, 0x1F00, 0x03B9,
+		0x1F01, 0x03B9, 0x1F02, 0x03B9, 0x1F03, 0x03B9, 0x1F04, 0x03B9, 0x1F05, 0x03B9,
+		0x1F06, 0x03B9, 0x1F07, 0x03B9, 0x1F20, 0x03B9, 0x1F21, 0x03B9, 0x1F22, 0x03B9,
+		0x1F23, 0x03B9, 0x1F24, 0x03B9, 0x1F25, 0x03B9, 0x1F26, 0x03B9, 0x1F27, 0x03B9,
+		0x1F20, 0x03B9, 0x1F21, 0x03B9, 0x1F22, 0x03B9, 0x1F23, 0x03B9, 0x1F24, 0x03B9,
+		0x1F25, 0x03B9, 0x1F26, 0x03B9, 0x1F27, 0x03B9, 0x1F60, 0x03B9, 0x1F61, 0x03B9,
+		0x1F62, 0x03B9, 0x1F63, 0x03B9, 0x1F64, 0x03B9, 0x1F65, 0x03B9, 0x1F66, 0x03B9,
+		0x1F67, 0x03B9, 0x1F60, 0x03B9, 0x1F61, 0x03B9, 0x1F62, 0x03B9, 0x1F63, 0x03B9,
+		0x1F64, 0x03B9, 0x1F65, 0x03B9, 0x1F66, 0x03B9, 0x1F67, 0x03B9, 0x1F70, 0x03B9,
+		0x03B1, 0x03B9, 0x03AC, 0x03B9, 0x03B1, 0x0342, 0x03B1, 0x0342, 0x03B9, 0x1FB0,
+		0x1FB1, 0x1F70, 0x1F71, 0x03B1, 0x03B9, 0x03B9, 0x1F74, 0x03B9, 0x03B7, 0x03B9,
+		0x03AE, 0x03B9, 0x03B7, 0x0342, 0x03B7, 0x0342, 0x03B9, 0x1F72, 0x1F73, 0x1F74,
+		0x1F75, 0x03B7, 0x03B9, 0x03B9, 0x0308, 0x0300, 0x03B9, 0x0308, 0x0301, 0x03B9,
+		0x0342, 0x03B9, 0x0308, 0x0342, 0x1FD0, 0x1FD1, 0x1F76, 0x1F77, 0x03C5, 0x0308,
+		0x0300, 0x03C5, 0x0308, 0x0301, 0x03C1, 0x0313, 0x03C5, 0x0342, 0x03C5, 0x0308,
+		0x0342, 0x1FE0, 0x1FE1, 0x1F7A, 0x1F7B, 0x1FE5, 0x1F7C, 0x03B9, 0x03C9, 0x03B9,
+		0x03CE, 0x03B9, 0x03C9, 0x0342, 0x03C9, 0x0342, 0x03B9, 0x1F78, 0x1F79, 0x1F7C,
+		0x1F7D, 0x03C9, 0x03B9, 0x03C9, 0x006B, 0x00E5, 0x214E, 0x2170, 0x2171, 0x2172,
+		0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C,
+		0x217D, 0x217E, 0x217F, 0x2184, 0x24D0, 0x24D1, 0x24D2, 0x24D3, 0x24D4, 0x24D5,
+		0x24D6, 0x24D7, 0x24D8, 0x24D9, 0x24DA, 0x24DB, 0x24DC, 0x24DD, 0x24DE, 0x24DF,
+		0x24E0, 0x24E1, 0x24E2, 0x24E3, 0x24E4, 0x24E5, 0x24E6, 0x24E7, 0x24E8, 0x24E9,
+		0x2C30, 0x2C31, 0x2C32, 0x2C33, 0x2C34, 0x2C35, 0x2C36, 0x2C37, 0x2C38, 0x2C39,
+		0x2C3A, 0x2C3B, 0x2C3C, 0x2C3D, 0x2C3E, 0x2C3F, 0x2C40, 0x2C41, 0x2C42, 0x2C43,
+		0x2C44, 0x2C45, 0x2C46, 0x2C47, 0x2C48, 0x2C49, 0x2C4A, 0x2C4B, 0x2C4C, 0x2C4D,
+		0x2C4E, 0x2C4F, 0x2C50, 0x2C51, 0x2C52, 0x2C53, 0x2C54, 0x2C55, 0x2C56, 0x2C57,
+		0x2C58, 0x2C59, 0x2C5A, 0x2C5B, 0x2C5C, 0x2C5D, 0x2C5E, 0x2C5F, 0x2C61, 0x026B,
+		0x1D7D, 0x027D, 0x2C68, 0x2C6A, 0x2C6C, 0x0251, 0x0271, 0x0250, 0x0252, 0x2C73,
+		0x2C76, 0x023F, 0x0240, 0x2C81, 0x2C83, 0x2C85, 0x2C87, 0x2C89, 0x2C8B, 0x2C8D,
+		0x2C8F, 0x2C91, 0x2C93, 0x2C95, 0x2C97, 0x2C99, 0x2C9B, 0x2C9D, 0x2C9F, 0x2CA1,
+		0x2CA3, 0x2CA5, 0x2CA7, 0x2CA9, 0x2CAB, 0x2CAD, 0x2CAF, 0x2CB1, 0x2CB3, 0x2CB5,
+		0x2CB7, 0x2CB9, 0x2CBB, 0x2CBD, 0x2CBF, 0x2CC1, 0x2CC3, 0x2CC5, 0x2CC7, 0x2CC9,
+		0x2CCB, 0x2CCD, 0x2CCF, 0x2CD1, 0x2CD3, 0x2CD5, 0x2CD7, 0x2CD9, 0x2CDB, 0x2CDD,
+		0x2CDF, 0x2CE1, 0x2CE3, 0x2CEC, 0x2CEE, 0x2CF3, 0xA641, 0xA643, 0xA645, 0xA647,
+		0xA649, 0xA64B, 0xA64D, 0xA64F, 0xA651, 0xA653, 0xA655, 0xA657, 0xA659, 0xA65B,
+		0xA65D, 0xA65F, 0xA661, 0xA663, 0xA665, 0xA667, 0xA669, 0xA66B, 0xA66D, 0xA681,
+		0xA683, 0xA685, 0xA687, 0xA689, 0xA68B, 0xA68D, 0xA68F, 0xA691, 0xA693, 0xA695,
+		0xA697, 0xA699, 0xA69B, 0xA723, 0xA725, 0xA727, 0xA729, 0xA72B, 0xA72D, 0xA72F,
+		0xA733, 0xA735, 0xA737, 0xA739, 0xA73B, 0xA73D, 0xA73F, 0xA741, 0xA743, 0xA745,
+		0xA747, 0xA749, 0xA74B, 0xA74D, 0xA74F, 0xA751, 0xA753, 0xA755, 0xA757, 0xA759,
+		0xA75B, 0xA75D, 0xA75F, 0xA761, 0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D,
+		0xA76F, 0xA77A, 0xA77C, 0x1D79, 0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C,
+		0x0265, 0xA791, 0xA793, 0xA797, 0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3,
+		0xA7A5, 0xA7A7, 0xA7A9, 0x0266, 0x025C, 0x0261, 0x026C, 0x026A, 0x029E, 0x0287,
+		0x029D, 0xAB53, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3,
+		0xA794, 0x0282, 0x1D8E, 0xA7C8, 0xA7CA, 0x0264, 0xA7CD, 0xA7CF, 0xA7D1, 0xA7D3,
+		0xA7D5, 0xA7D7, 0xA7D9, 0xA7DB, 0x019B, 0x0277, 0x027C, 0xA7F6, 0xAB4B, 0xAB4C,
+		0x13A0, 0x13A1, 0x13A2, 0x13A3, 0x13A4, 0x13A5, 0x13A6, 0x13A7, 0x13A8, 0x13A9,
+		0x13AA, 0x13AB, 0x13AC, 0x13AD, 0x13AE, 0x13AF, 0x13B0, 0x13B1, 0x13B2, 0x13B3,
+		0x13B4, 0x13B5, 0x13B6, 0x13B7, 0x13B8, 0x13B9, 0x13BA, 0x13BB, 0x13BC, 0x13BD,
+		0x13BE, 0x13BF, 0x13C0, 0x13C1, 0x13C2, 0x13C3, 0x13C4, 0x13C5, 0x13C6, 0x13C7,
+		0x13C8, 0x13C9, 0x13CA, 0x13CB, 0x13CC, 0x13CD, 0x13CE, 0x13CF, 0x13D0, 0x13D1,
+		0x13D2, 0x13D3, 0x13D4, 0x13D5, 0x13D6, 0x13D7, 0x13D8, 0x13D9, 0x13DA, 0x13DB,
+		0x13DC, 0x13DD, 0x13DE, 0x13DF, 0x13E0, 0x13E1, 0x13E2, 0x13E3, 0x13E4, 0x13E5,
+		0x13E6, 0x13E7, 0x13E8, 0x13E9, 0x13EA, 0x13EB, 0x13EC, 0x13ED, 0x13EE, 0x13EF,
+		0x0066, 0x0066, 0x0066, 0x0069, 0x0066, 0x006C, 0x0066, 0x0066, 0x0069, 0x0066,
+		0x0066, 0x006C, 0x0073, 0x0074, 0x0073, 0x0074, 0x0574, 0x0576, 0x0574, 0x0565,
+		0x0574, 0x056B, 0x057E, 0x0576, 0x0574, 0x056D, 0xFF41, 0xFF42, 0xFF43, 0xFF44,
+		0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E,
+		0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58,
+		0xFF59, 0xFF5A, 0x10428, 0x10429, 0x1042A, 0x1042B, 0x1042C, 0x1042D, 0x1042E, 0x1042F,
+		0x10430, 0x10431, 0x10432, 0x10433, 0x10434, 0x10435, 0x10436, 0x10437, 0x10438, 0x10439,
+		0x1043A, 0x1043B, 0x1043C, 0x1043D, 0x1043E, 0x1043F, 0x10440, 0x10441, 0x10442, 0x10443,
+		0x10444, 0x10445, 0x10446, 0x10447, 0x10448, 0x10449, 0x1044A, 0x1044B, 0x1044C, 0x1044D,
+		0x1044E, 0x1044F, 0x104D8, 0x104D9, 0x104DA, 0x104DB, 0x104DC, 0x104DD, 0x104DE, 0x104DF,
+		0x104E0, 0x104E1, 0x104E2, 0x104E3, 0x104E4, 0x104E5, 0x104E6, 0x104E7, 0x104E8, 0x104E9,
+		0x104EA, 0x104EB, 0x104EC, 0x104ED, 0x104EE, 0x104EF, 0x104F0, 0x104F1, 0x104F2, 0x104F3,
+		0x104F4, 0x104F5, 0x104F6, 0x104F7, 0x104F8, 0x104F9, 0x104FA, 0x104FB, 0x10597, 0x10598,
+		0x10599, 0x1059A, 0x1059B, 0x1059C, 0x1059D, 0x1059E, 0x1059F, 0x105A0, 0x105A1, 0x105A3,
+		0x105A4, 0x105A5, 0x105A6, 0x105A7, 0x105A8, 0x105A9, 0x105AA, 0x105AB, 0x105AC, 0x105AD,
+		0x105AE, 0x105AF, 0x105B0, 0x105B1, 0x105B3, 0x105B4, 0x105B5, 0x105B6, 0x105B7, 0x105B8,
+		0x105B9, 0x105BB, 0x105BC, 0x10CC0, 0x10CC1, 0x10CC2, 0x10CC3, 0x10CC4, 0x10CC5, 0x10CC6,
+		0x10CC7, 0x10CC8, 0x10CC9, 0x10CCA, 0x10CCB, 0x10CCC, 0x10CCD, 0x10CCE, 0x10CCF, 0x10CD0,
+		0x10CD1, 0x10CD2, 0x10CD3, 0x10CD4, 0x10CD5, 0x10CD6, 0x10CD7, 0x10CD8, 0x10CD9, 0x10CDA,
+		0x10CDB, 0x10CDC, 0x10CDD, 0x10CDE, 0x10CDF, 0x10CE0, 0x10CE1, 0x10CE2, 0x10CE3, 0x10CE4,
+		0x10CE5, 0x10CE6, 0x10CE7, 0x10CE8, 0x10CE9, 0x10CEA, 0x10CEB, 0x10CEC, 0x10CED, 0x10CEE,
+		0x10CEF, 0x10CF0, 0x10CF1, 0x10CF2, 0x10D70, 0x10D71, 0x10D72, 0x10D73, 0x10D74, 0x10D75,
+		0x10D76, 0x10D77, 0x10D78, 0x10D79, 0x10D7A, 0x10D7B, 0x10D7C, 0x10D7D, 0x10D7E, 0x10D7F,
+		0x10D80, 0x10D81, 0x10D82, 0x10D83, 0x10D84, 0x10D85, 0x118C0, 0x118C1, 0x118C2, 0x118C3,
+		0x118C4, 0x118C5, 0x118C6, 0x118C7, 0x118C8, 0x118C9, 0x118CA, 0x118CB, 0x118CC, 0x118CD,
+		0x118CE, 0x118CF, 0x118D0, 0x118D1, 0x118D2, 0x118D3, 0x118D4, 0x118D5, 0x118D6, 0x118D7,
+		0x118D8, 0x118D9, 0x118DA, 0x118DB, 0x118DC, 0x118DD, 0x118DE, 0x118DF, 0x16E60, 0x16E61,
+		0x16E62, 0x16E63, 0x16E64, 0x16E65, 0x16E66, 0x16E67, 0x16E68, 0x16E69, 0x16E6A, 0x16E6B,
+		0x16E6C, 0x16E6D, 0x16E6E, 0x16E6F, 0x16E70, 0x16E71, 0x16E72, 0x16E73, 0x16E74, 0x16E75,
+		0x16E76, 0x16E77, 0x16E78, 0x16E79, 0x16E7A, 0x16E7B, 0x16E7C, 0x16E7D, 0x16E7E, 0x16E7F,
+		0x16EBB, 0x16EBC, 0x16EBD, 0x16EBE, 0x16EBF, 0x16EC0, 0x16EC1, 0x16EC2, 0x16EC3, 0x16EC4,
+		0x16EC5, 0x16EC6, 0x16EC7, 0x16EC8, 0x16EC9, 0x16ECA, 0x16ECB, 0x16ECC, 0x16ECD, 0x16ECE,
+		0x16ECF, 0x16ED0, 0x16ED1, 0x16ED2, 0x16ED3, 0x1DF41, 0x1DF49, 0x1DF4B, 0x1DF4E, 0x1DF52,
+		0x1DF69, 0x1DF6B, 0x1DF6D, 0x1DF6F, 0x1DF73, 0x1DF75, 0x1DF77, 0x1DF79, 0x1DF7B, 0x1DF7D,
+		0x1DF7F, 0x0073, 0x0073, 0x1E922, 0x1E923, 0x1E924, 0x1E925, 0x1E926, 0x1E927, 0x1E928,
+		0x1E929, 0x1E92A, 0x1E92B, 0x1E92C, 0x1E92D, 0x1E92E, 0x1E92F, 0x1E930, 0x1E931, 0x1E932,
+		0x1E933, 0x1E934, 0x1E935, 0x1E936, 0x1E937, 0x1E938, 0x1E939, 0x1E93A, 0x1E93B, 0x1E93C,
+		0x1E93D, 0x1E93E, 0x1E93F, 0x1E940, 0x1E941, 0x1E942, 0x1E943,
+	},
+}
+
+// vs15Bases are the characters of an emoji variation sequence with U+FE0E.
+var vs15Bases = []rune{
+	0x0023, 0x002A, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+	0x0038, 0x0039, 0x00A9, 0x00AE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2194, 0x2195,
+	0x2196, 0x2197, 0x2198, 0x2199, 0x21A9, 0x21AA, 0x231A, 0x231B, 0x2328, 0x23CF,
+	0x23E9, 0x23EA, 0x23EB, 0x23EC, 0x23ED, 0x23EE, 0x23EF, 0x23F0, 0x23F1, 0x23F2,
+	0x23F3, 0x23F8, 0x23F9, 0x23FA, 0x24C2, 0x25AA, 0x25AB, 0x25B6, 0x25C0, 0x25FB,
+	0x25FC, 0x25FD, 0x25FE, 0x2600, 0x2601, 0x2602, 0x2603, 0x2604, 0x260E, 0x2611,
+	0x2614, 0x2615, 0x2618, 0x261D, 0x2620, 0x2622, 0x2623, 0x2626, 0x262A, 0x262E,
+	0x262F, 0x2638, 0x2639, 0x263A, 0x2640, 0x2642, 0x2648, 0x2649, 0x264A, 0x264B,
+	0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x265F, 0x2660,
+	0x2663, 0x2665, 0x2666, 0x2668, 0x267B, 0x267E, 0x267F, 0x2692, 0x2693, 0x2694,
+	0x2695, 0x2696, 0x2697, 0x2699, 0x269B, 0x269C, 0x26A0, 0x26A1, 0x26A7, 0x26AA,
+	0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, 0x26C8, 0x26CE, 0x26CF,
+	0x26D1, 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4,
+	0x26F5, 0x26F7, 0x26F8, 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2705, 0x2708, 0x2709,
+	0x270A, 0x270B, 0x270C, 0x270D, 0x270F, 0x2712, 0x2714, 0x2716, 0x271D, 0x2721,
+	0x2728, 0x2733, 0x2734, 0x2744, 0x2747, 0x274C, 0x274E, 0x2753, 0x2754, 0x2755,
+	0x2757, 0x2763, 0x2764, 0x2795, 0x2796, 0x2797, 0x27A1, 0x27B0, 0x27BF, 0x2934,
+	0x2935, 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D,
+	0x3297, 0x3299, 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F,
+	0x1F237, 0x1F30D, 0x1F30E, 0x1F30F, 0x1F315, 0x1F31C, 0x1F321, 0x1F324, 0x1F325, 0x1F326,
+	0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, 0x1F336, 0x1F378, 0x1F37D, 0x1F393,
+	0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3A7, 0x1F3AC, 0x1F3AD,
+	0x1F3AE, 0x1F3C2, 0x1F3C4, 0x1F3C6, 0x1F3CA, 0x1F3CB, 0x1F3CC, 0x1F3CD, 0x1F3CE, 0x1F3D4,
+	0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, 0x1F3DB, 0x1F3DC, 0x1F3DD, 0x1F3DE,
+	0x1F3DF, 0x1F3E0, 0x1F3ED, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F408, 0x1F415, 0x1F41F, 0x1F426,
+	0x1F43F, 0x1F441, 0x1F442, 0x1F446, 0x1F447, 0x1F448, 0x1F449, 0x1F44D, 0x1F44E, 0x1F453,
+	0x1F46A, 0x1F47D, 0x1F4A3, 0x1F4B0, 0x1F4B3, 0x1F4BB, 0x1F4BF, 0x1F4CB, 0x1F4DA, 0x1F4DF,
+	0x1F4E4, 0x1F4E5, 0x1F4E6, 0x1F4EA, 0x1F4EB, 0x1F4EC, 0x1F4ED, 0x1F4F7, 0x1F4F9, 0x1F4FA,
+	0x1F4FB, 0x1F4FD, 0x1F508, 0x1F50D, 0x1F512, 0x1F513, 0x1F549, 0x1F54A, 0x1F550, 0x1F551,
+	0x1F552, 0x1F553, 0x1F554, 0x1F555, 0x1F556, 0x1F557, 0x1F558, 0x1F559, 0x1F55A, 0x1F55B,
+	0x1F55C, 0x1F55D, 0x1F55E, 0x1F55F, 0x1F560, 0x1F561, 0x1F562, 0x1F563, 0x1F564, 0x1F565,
+	0x1F566, 0x1F567, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, 0x1F578,
+	0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, 0x1F5B1,
+	0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, 0x1F5DD,
+	0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F610, 0x1F687, 0x1F68D,
+	0x1F691, 0x1F694, 0x1F698, 0x1F6AD, 0x1F6B2, 0x1F6B9, 0x1F6BA, 0x1F6BC, 0x1F6CB, 0x1F6CD,
+	0x1F6CE, 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0,
+	0x1F6F3,
+}
+
+// vs16Bases are the characters of an emoji variation sequence with U+FE0F.
+var vs16Bases = []rune{
+	0x0023, 0x002A, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+	0x0038, 0x0039, 0x00A9, 0x00AE, 0x203C, 0x2049, 0x2122, 0x2139, 0x2194, 0x2195,
+	0x2196, 0x2197, 0x2198, 0x2199, 0x21A9, 0x21AA, 0x231A, 0x231B, 0x2328, 0x23CF,
+	0x23E9, 0x23EA, 0x23EB, 0x23EC, 0x23ED, 0x23EE, 0x23EF, 0x23F0, 0x23F1, 0x23F2,
+	0x23F3, 0x23F8, 0x23F9, 0x23FA, 0x24C2, 0x25AA, 0x25AB, 0x25B6, 0x25C0, 0x25FB,
+	0x25FC, 0x25FD, 0x25FE, 0x2600, 0x2601, 0x2602, 0x2603, 0x2604, 0x260E, 0x2611,
+	0x2614, 0x2615, 0x2618, 0x261D, 0x2620, 0x2622, 0x2623, 0x2626, 0x262A, 0x262E,
+	0x262F, 0x2638, 0x2639, 0x263A, 0x2640, 0x2642, 0x2648, 0x2649, 0x264A, 0x264B,
+	0x264C, 0x264D, 0x264E, 0x264F, 0x2650, 0x2651, 0x2652, 0x2653, 0x265F, 0x2660,
+	0x2663, 0x2665, 0x2666, 0x2668, 0x267B, 0x267E, 0x267F, 0x2692, 0x2693, 0x2694,
+	0x2695, 0x2696, 0x2697, 0x2699, 0x269B, 0x269C, 0x26A0, 0x26A1, 0x26A7, 0x26AA,
+	0x26AB, 0x26B0, 0x26B1, 0x26BD, 0x26BE, 0x26C4, 0x26C5, 0x26C8, 0x26CE, 0x26CF,
+	0x26D1, 0x26D3, 0x26D4, 0x26E9, 0x26EA, 0x26F0, 0x26F1, 0x26F2, 0x26F3, 0x26F4,
+	0x26F5, 0x26F7, 0x26F8, 0x26F9, 0x26FA, 0x26FD, 0x2702, 0x2705, 0x2708, 0x2709,
+	0x270A, 0x270B, 0x270C, 0x270D, 0x270F, 0x2712, 0x2714, 0x2716, 0x271D, 0x2721,
+	0x2728, 0x2733, 0x2734, 0x2744, 0x2747, 0x274C, 0x274E, 0x2753, 0x2754, 0x2755,
+	0x2757, 0x2763, 0x2764, 0x2795, 0x2796, 0x2797, 0x27A1, 0x27B0, 0x27BF, 0x2934,
+	0x2935, 0x2B05, 0x2B06, 0x2B07, 0x2B1B, 0x2B1C, 0x2B50, 0x2B55, 0x3030, 0x303D,
+	0x3297, 0x3299, 0x1F004, 0x1F170, 0x1F171, 0x1F17E, 0x1F17F, 0x1F202, 0x1F21A, 0x1F22F,
+	0x1F237, 0x1F30D, 0x1F30E, 0x1F30F, 0x1F315, 0x1F31C, 0x1F321, 0x1F324, 0x1F325, 0x1F326,
+	0x1F327, 0x1F328, 0x1F329, 0x1F32A, 0x1F32B, 0x1F32C, 0x1F336, 0x1F378, 0x1F37D, 0x1F393,
+	0x1F396, 0x1F397, 0x1F399, 0x1F39A, 0x1F39B, 0x1F39E, 0x1F39F, 0x1F3A7, 0x1F3AC, 0x1F3AD,
+	0x1F3AE, 0x1F3C2, 0x1F3C4, 0x1F3C6, 0x1F3CA, 0x1F3CB, 0x1F3CC, 0x1F3CD, 0x1F3CE, 0x1F3D4,
+	0x1F3D5, 0x1F3D6, 0x1F3D7, 0x1F3D8, 0x1F3D9, 0x1F3DA, 0x1F3DB, 0x1F3DC, 0x1F3DD, 0x1F3DE,
+	0x1F3DF, 0x1F3E0, 0x1F3ED, 0x1F3F3, 0x1F3F5, 0x1F3F7, 0x1F408, 0x1F415, 0x1F41F, 0x1F426,
+	0x1F43F, 0x1F441, 0x1F442, 0x1F446, 0x1F447, 0x1F448, 0x1F449, 0x1F44D, 0x1F44E, 0x1F453,
+	0x1F46A, 0x1F47D, 0x1F4A3, 0x1F4B0, 0x1F4B3, 0x1F4BB, 0x1F4BF, 0x1F4CB, 0x1F4DA, 0x1F4DF,
+	0x1F4E4, 0x1F4E5, 0x1F4E6, 0x1F4EA, 0x1F4EB, 0x1F4EC, 0x1F4ED, 0x1F4F7, 0x1F4F9, 0x1F4FA,
+	0x1F4FB, 0x1F4FD, 0x1F508, 0x1F50D, 0x1F512, 0x1F513, 0x1F549, 0x1F54A, 0x1F550, 0x1F551,
+	0x1F552, 0x1F553, 0x1F554, 0x1F555, 0x1F556, 0x1F557, 0x1F558, 0x1F559, 0x1F55A, 0x1F55B,
+	0x1F55C, 0x1F55D, 0x1F55E, 0x1F55F, 0x1F560, 0x1F561, 0x1F562, 0x1F563, 0x1F564, 0x1F565,
+	0x1F566, 0x1F567, 0x1F56F, 0x1F570, 0x1F573, 0x1F574, 0x1F575, 0x1F576, 0x1F577, 0x1F578,
+	0x1F579, 0x1F587, 0x1F58A, 0x1F58B, 0x1F58C, 0x1F58D, 0x1F590, 0x1F5A5, 0x1F5A8, 0x1F5B1,
+	0x1F5B2, 0x1F5BC, 0x1F5C2, 0x1F5C3, 0x1F5C4, 0x1F5D1, 0x1F5D2, 0x1F5D3, 0x1F5DC, 0x1F5DD,
+	0x1F5DE, 0x1F5E1, 0x1F5E3, 0x1F5E8, 0x1F5EF, 0x1F5F3, 0x1F5FA, 0x1F610, 0x1F687, 0x1F68D,
+	0x1F691, 0x1F694, 0x1F698, 0x1F6AD, 0x1F6B2, 0x1F6B9, 0x1F6BA, 0x1F6BC, 0x1F6CB, 0x1F6CD,
+	0x1F6CE, 0x1F6CF, 0x1F6E0, 0x1F6E1, 0x1F6E2, 0x1F6E3, 0x1F6E4, 0x1F6E5, 0x1F6E9, 0x1F6F0,
+	0x1F6F3,
+}
+
+// bestFitTables are, for each code page of WindowsBestFit, the code points
+// of U+0080 and above that it maps to a single ASCII byte.
+var bestFitTables = []bestFitTable{
+	{
+		name: "874",
+		from: []rune{
+			0x00A7, 0x00B6, 0x203C, 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x21A8,
+			0x221F, 0x2302, 0x25AC, 0x25B2, 0x25BA, 0x25BC, 0x25C4, 0x25CB, 0x25D8, 0x25D9,
+			0x263A, 0x263B, 0x263C, 0x2640, 0x2642, 0x2660, 0x2663, 0x2665, 0x2666, 0x266A,
+			0x266B, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09,
+			0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13,
+			0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D,
+			0xFF1E, 0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27,
+			0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31,
+			0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B,
+			0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45,
+			0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,
+			0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59,
+			0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x15, 0x14, 0x13, 0x1B, 0x18, 0x1A, 0x19, 0x1D, 0x12, 0x17, 0x1C, 0x7F, 0x16, 0x1E, 0x10, 0x1F,
+			0x11, 0x09, 0x08, 0x0A, 0x01, 0x02, 0x0F, 0x0C, 0x0B, 0x06, 0x05, 0x03, 0x04, 0x0D, 0x0E, 0x21,
+			0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31,
+			0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41,
+			0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51,
+			0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61,
+			0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+			0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "932",
+		from: []rune{
+			0x00A1, 0x00A5, 0x00A6, 0x00A9, 0x00AA, 0x00AD, 0x00AE, 0x00B2, 0x00B3, 0x00B9,
+			0x00BA, 0x00BF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
+			0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1,
+			0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC,
+			0x00DD, 0x00DE, 0x00DF, 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6,
+			0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0,
+			0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F8, 0x00F9, 0x00FA, 0x00FB,
+			0x00FC, 0x00FD, 0x00FE, 0x00FF,
+		},
+		to: []byte{
+			0x21, 0x5C, 0x7C, 0x63, 0x61, 0x2D, 0x52, 0x32, 0x33, 0x31, 0x6F, 0x3F, 0x41, 0x41, 0x41, 0x41,
+			0x41, 0x41, 0x41, 0x43, 0x45, 0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49, 0x44, 0x4E, 0x4F, 0x4F,
+			0x4F, 0x4F, 0x4F, 0x4F, 0x55, 0x55, 0x55, 0x55, 0x59, 0x54, 0x73, 0x61, 0x61, 0x61, 0x61, 0x61,
+			0x61, 0x61, 0x63, 0x65, 0x65, 0x65, 0x65, 0x69, 0x69, 0x69, 0x69, 0x64, 0x6E, 0x6F, 0x6F, 0x6F,
+			0x6F, 0x6F, 0x6F, 0x75, 0x75, 0x75, 0x75, 0x79, 0x74, 0x79,
+		},
+	},
+	{
+		name: "936",
+		from: []rune{
+			0x00A6, 0x00AA, 0x00AD, 0x00B2, 0x00B3, 0x00B9, 0x00BA, 0x00D0, 0x00DD, 0x00DE,
+			0x00E2, 0x00F0, 0x00FD, 0x00FE,
+		},
+		to: []byte{
+			0x7C, 0x61, 0x2D, 0x32, 0x33, 0x31, 0x6F, 0x44, 0x59, 0x54, 0x61, 0x65, 0x79, 0x74,
+		},
+	},
+	{
+		name: "949",
+		from: []rune{
+			0x00A6, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C7, 0x00C8, 0x00C9,
+			0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D1, 0x00D2, 0x00D3, 0x00D4,
+			0x00D5, 0x00D6, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00E0, 0x00E1, 0x00E2,
+			0x00E3, 0x00E4, 0x00E5, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED,
+			0x00EE, 0x00EF, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F9, 0x00FA,
+			0x00FB, 0x00FC, 0x00FD, 0x00FF, 0x20A9,
+		},
+		to: []byte{
+			0x7C, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x43, 0x45, 0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
+			0x4E, 0x4F, 0x4F, 0x4F, 0x4F, 0x4F, 0x55, 0x55, 0x55, 0x55, 0x59, 0x61, 0x61, 0x61, 0x61, 0x61,
+			0x61, 0x63, 0x65, 0x65, 0x65, 0x65, 0x69, 0x69, 0x69, 0x69, 0x6E, 0x6F, 0x6F, 0x6F, 0x6F, 0x6F,
+			0x75, 0x75, 0x75, 0x75, 0x79, 0x79, 0x5C,
+		},
+	},
+	{
+		name: "950",
+		from: []rune{
+			0x00A1, 0x00A6, 0x00A9, 0x00AA, 0x00AD, 0x00AE, 0x00B2, 0x00B3, 0x00B9, 0x00BA,
+			0x00BF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8,
+			0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D0, 0x00D1, 0x00D2,
+			0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD,
+			0x00DE, 0x00DF, 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
+			0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1,
+			0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC,
+			0x00FD, 0x00FE, 0x00FF,
+		},
+		to: []byte{
+			0x21, 0x7C, 0x63, 0x61, 0x2D, 0x52, 0x32, 0x33, 0x31, 0x6F, 0x3F, 0x41, 0x41, 0x41, 0x41, 0x41,
+			0x41, 0x41, 0x43, 0x45, 0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49, 0x44, 0x4E, 0x4F, 0x4F, 0x4F,
+			0x4F, 0x4F, 0x4F, 0x55, 0x55, 0x55, 0x55, 0x59, 0x54, 0x73, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
+			0x61, 0x63, 0x65, 0x65, 0x65, 0x65, 0x69, 0x69, 0x69, 0x69, 0x65, 0x6E, 0x6F, 0x6F, 0x6F, 0x6F,
+			0x6F, 0x6F, 0x75, 0x75, 0x75, 0x75, 0x79, 0x74, 0x79,
+		},
+	},
+	{
+		name: "1250",
+		from: []rune{
+			0x00A1, 0x00A2, 0x00A3, 0x00A5, 0x00AA, 0x00B2, 0x00B3, 0x00B9, 0x00BA, 0x00BC,
+			0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C3, 0x00C5, 0x00C6, 0x00C8, 0x00CA, 0x00CC,
+			0x00CF, 0x00D1, 0x00D2, 0x00D5, 0x00D8, 0x00D9, 0x00DB, 0x00E0, 0x00E3, 0x00E5,
+			0x00E6, 0x00E8, 0x00EA, 0x00EC, 0x00EF, 0x00F1, 0x00F2, 0x00F5, 0x00F8, 0x00F9,
+			0x00FB, 0x00FF, 0x0100, 0x0101, 0x0108, 0x0109, 0x010A, 0x010B, 0x0112, 0x0113,
+			0x0114, 0x0115, 0x0116, 0x0117, 0x011C, 0x011D, 0x011E, 0x011F, 0x0120, 0x0121,
+			0x0122, 0x0123, 0x0124, 0x0125, 0x0126, 0x0127, 0x0128, 0x0129, 0x012A, 0x012B,
+			0x012C, 0x012D, 0x012E, 0x012F, 0x0130, 0x0131, 0x0134, 0x0135, 0x0136, 0x0137,
+			0x013B, 0x013C, 0x0145, 0x0146, 0x014C, 0x014D, 0x014E, 0x014F, 0x0152, 0x0153,
+			0x0156, 0x0157, 0x015C, 0x015D, 0x0166, 0x0167, 0x0168, 0x0169, 0x016A, 0x016B,
+			0x016C, 0x016D, 0x0172, 0x0173, 0x0174, 0x0175, 0x0176, 0x0177, 0x0178, 0x0180,
+			0x0191, 0x0192, 0x0197, 0x019A, 0x019F, 0x01A0, 0x01A1, 0x01AB, 0x01AE, 0x01AF,
+			0x01B0, 0x01B6, 0x01C0, 0x01C3, 0x01CD, 0x01CE, 0x01CF, 0x01D0, 0x01D1, 0x01D2,
+			0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC,
+			0x01DE, 0x01DF, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB,
+			0x01EC, 0x01ED, 0x01F0, 0x0261, 0x02B9, 0x02BA, 0x02BC, 0x02C4, 0x02C6, 0x02C8,
+			0x02CB, 0x02CD, 0x02DC, 0x0300, 0x0302, 0x0303, 0x030E, 0x0331, 0x0332, 0x037E,
+			0x04BB, 0x0589, 0x066A, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006,
+			0x2010, 0x2011, 0x2032, 0x2035, 0x203C, 0x2044, 0x2074, 0x2075, 0x2076, 0x2077,
+			0x2078, 0x2080, 0x2081, 0x2082, 0x2083, 0x2084, 0x2085, 0x2086, 0x2087, 0x2088,
+			0x2089, 0x2102, 0x2107, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E, 0x2110, 0x2111,
+			0x2112, 0x2113, 0x2115, 0x2118, 0x2119, 0x211A, 0x211B, 0x211C, 0x211D, 0x2124,
+			0x2128, 0x212A, 0x212C, 0x212D, 0x212E, 0x212F, 0x2130, 0x2131, 0x2133, 0x2134,
+			0x2191, 0x2194, 0x2195, 0x21A8, 0x2212, 0x2215, 0x2216, 0x2217, 0x221F, 0x2223,
+			0x2236, 0x223C, 0x2303, 0x2329, 0x232A, 0x2502, 0x250C, 0x2514, 0x2518, 0x251C,
+			0x2524, 0x252C, 0x2534, 0x253C, 0x2550, 0x2554, 0x255A, 0x255D, 0x2566, 0x256C,
+			0x2580, 0x2584, 0x2588, 0x2591, 0x2592, 0x2593, 0x25AC, 0x25B2, 0x25BA, 0x25C4,
+			0x25CB, 0x25D9, 0x263C, 0x2640, 0x2642, 0x266A, 0x266B, 0x2758, 0x3000, 0x3008,
+			0x3009, 0x301A, 0x301B, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07,
+			0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11,
+			0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B,
+			0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25,
+			0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F,
+			0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39,
+			0xFF3A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43,
+			0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D,
+			0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57,
+			0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x21, 0x63, 0x4C, 0x59, 0x61, 0x32, 0x33, 0x31, 0x6F, 0x31, 0x31, 0x33, 0x3F, 0x41, 0x41, 0x41,
+			0x41, 0x45, 0x45, 0x49, 0x49, 0x4E, 0x4F, 0x4F, 0x4F, 0x55, 0x55, 0x61, 0x61, 0x61, 0x61, 0x65,
+			0x65, 0x69, 0x69, 0x6E, 0x6F, 0x6F, 0x6F, 0x75, 0x75, 0x79, 0x41, 0x61, 0x43, 0x63, 0x43, 0x63,
+			0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x47, 0x67, 0x47, 0x67, 0x47, 0x67, 0x47, 0x67, 0x48, 0x68,
+			0x48, 0x68, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x4A, 0x6A, 0x4B, 0x6B,
+			0x4C, 0x6C, 0x4E, 0x6E, 0x4F, 0x6F, 0x4F, 0x6F, 0x4F, 0x6F, 0x52, 0x72, 0x53, 0x73, 0x54, 0x74,
+			0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x57, 0x77, 0x59, 0x79, 0x59, 0x62, 0x46, 0x66,
+			0x49, 0x6C, 0x4F, 0x4F, 0x6F, 0x74, 0x54, 0x55, 0x75, 0x7A, 0x7C, 0x21, 0x41, 0x61, 0x49, 0x69,
+			0x4F, 0x6F, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x41, 0x61, 0x47, 0x67,
+			0x47, 0x67, 0x4B, 0x6B, 0x4F, 0x6F, 0x4F, 0x6F, 0x6A, 0x67, 0x27, 0x22, 0x27, 0x5E, 0x5E, 0x27,
+			0x60, 0x5F, 0x7E, 0x60, 0x5E, 0x7E, 0x22, 0x5F, 0x5F, 0x3B, 0x68, 0x3A, 0x25, 0x20, 0x20, 0x20,
+			0x20, 0x20, 0x20, 0x20, 0x2D, 0x2D, 0x27, 0x60, 0x21, 0x2F, 0x34, 0x35, 0x36, 0x37, 0x38, 0x30,
+			0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x43, 0x45, 0x67, 0x48, 0x48, 0x48, 0x68,
+			0x49, 0x49, 0x4C, 0x6C, 0x4E, 0x50, 0x50, 0x51, 0x52, 0x52, 0x52, 0x5A, 0x5A, 0x4B, 0x42, 0x43,
+			0x65, 0x65, 0x45, 0x46, 0x4D, 0x6F, 0x5E, 0x2D, 0x7C, 0x7C, 0x2D, 0x2F, 0x5C, 0x2A, 0x4C, 0x7C,
+			0x3A, 0x7E, 0x5E, 0x3C, 0x3E, 0x2D, 0x2D, 0x4C, 0x2D, 0x2B, 0x2B, 0x54, 0x2B, 0x2B, 0x3D, 0x2D,
+			0x4C, 0x2D, 0x54, 0x2B, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x5E, 0x3E, 0x3C, 0x30, 0x30,
+			0x30, 0x2B, 0x3E, 0x64, 0x64, 0x7C, 0x20, 0x3C, 0x3E, 0x5B, 0x5D, 0x21, 0x22, 0x23, 0x24, 0x25,
+			0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+			0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
+			0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
+			0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65,
+			0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+			0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1251",
+		from: []rune{
+			0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C7, 0x00C8, 0x00C9, 0x00CA,
+			0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5,
+			0x00D6, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00E0, 0x00E1, 0x00E2,
+			0x00E3, 0x00E4, 0x00E5, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED,
+			0x00EE, 0x00EF, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F8, 0x00F9,
+			0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FF, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104,
+			0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D, 0x010E,
+			0x010F, 0x0110, 0x0111, 0x0112, 0x0113, 0x0114, 0x0115, 0x0116, 0x0117, 0x0118,
+			0x0119, 0x011A, 0x011B, 0x011C, 0x011D, 0x011E, 0x011F, 0x0120, 0x0121, 0x0122,
+			0x0123, 0x0124, 0x0125, 0x0126, 0x0127, 0x0128, 0x0129, 0x012A, 0x012B, 0x012C,
+			0x012D, 0x012E, 0x012F, 0x0130, 0x0134, 0x0135, 0x0136, 0x0137, 0x0139, 0x013A,
+			0x013B, 0x013C, 0x013D, 0x013E, 0x0141, 0x0142, 0x0143, 0x0144, 0x0145, 0x0146,
+			0x0147, 0x0148, 0x014C, 0x014D, 0x014E, 0x014F, 0x0150, 0x0151, 0x0154, 0x0155,
+			0x0156, 0x0157, 0x0158, 0x0159, 0x015A, 0x015B, 0x015C, 0x015D, 0x015E, 0x015F,
+			0x0160, 0x0161, 0x0162, 0x0163, 0x0164, 0x0165, 0x0166, 0x0167, 0x0168, 0x0169,
+			0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F, 0x0170, 0x0171, 0x0172, 0x0173,
+			0x0174, 0x0175, 0x0176, 0x0177, 0x0178, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D,
+			0x017E, 0x0180, 0x0197, 0x019A, 0x019F, 0x01A0, 0x01A1, 0x01AB, 0x01AE, 0x01AF,
+			0x01B0, 0x01CD, 0x01CE, 0x01CF, 0x01D0, 0x01D1, 0x01D2, 0x01D3, 0x01D4, 0x01D5,
+			0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC, 0x01DE, 0x01DF, 0x01E4,
+			0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01F0,
+			0x203C, 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x221A, 0x221F, 0x2500, 0x250C,
+			0x2514, 0x2518, 0x251C, 0x2524, 0x252C, 0x2534, 0x253C, 0x2550, 0x2552, 0x2558,
+			0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x2564, 0x2565, 0x2566, 0x256A, 0x256B,
+			0x256C, 0x2580, 0x2584, 0x2588, 0x2591, 0x2592, 0x2593, 0x25AC, 0x25B2, 0x25BA,
+			0x25C4, 0x25CB, 0x25D9, 0x263A, 0x263B, 0x263C, 0x2640, 0x2642, 0x266A, 0x266B,
+			0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A,
+			0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14,
+			0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E,
+			0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28,
+			0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32,
+			0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B, 0xFF3C,
+			0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46,
+			0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50,
+			0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A,
+			0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x43, 0x45, 0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49, 0x4E,
+			0x4F, 0x4F, 0x4F, 0x4F, 0x4F, 0x4F, 0x55, 0x55, 0x55, 0x55, 0x59, 0x61, 0x61, 0x61, 0x61, 0x61,
+			0x61, 0x63, 0x65, 0x65, 0x65, 0x65, 0x69, 0x69, 0x69, 0x69, 0x6E, 0x6F, 0x6F, 0x6F, 0x6F, 0x6F,
+			0x6F, 0x75, 0x75, 0x75, 0x75, 0x79, 0x79, 0x41, 0x61, 0x41, 0x61, 0x41, 0x61, 0x43, 0x63, 0x43,
+			0x63, 0x43, 0x63, 0x43, 0x63, 0x44, 0x64, 0x44, 0x64, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x45,
+			0x65, 0x45, 0x65, 0x47, 0x67, 0x47, 0x67, 0x47, 0x67, 0x47, 0x67, 0x48, 0x68, 0x48, 0x68, 0x49,
+			0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x4A, 0x6A, 0x4B, 0x6B, 0x4C, 0x6C, 0x4C, 0x6C,
+			0x4C, 0x6C, 0x4C, 0x6C, 0x4E, 0x6E, 0x4E, 0x6E, 0x4E, 0x6E, 0x4F, 0x6F, 0x4F, 0x6F, 0x4F, 0x6F,
+			0x52, 0x72, 0x52, 0x72, 0x52, 0x72, 0x53, 0x73, 0x53, 0x73, 0x53, 0x73, 0x53, 0x73, 0x54, 0x74,
+			0x54, 0x74, 0x54, 0x74, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75,
+			0x57, 0x77, 0x59, 0x79, 0x59, 0x5A, 0x7A, 0x5A, 0x7A, 0x5A, 0x7A, 0x62, 0x49, 0x6C, 0x4F, 0x4F,
+			0x6F, 0x74, 0x54, 0x55, 0x75, 0x41, 0x61, 0x49, 0x69, 0x4F, 0x6F, 0x55, 0x75, 0x55, 0x75, 0x55,
+			0x75, 0x55, 0x75, 0x55, 0x75, 0x41, 0x61, 0x47, 0x67, 0x47, 0x67, 0x4B, 0x6B, 0x4F, 0x6F, 0x4F,
+			0x6F, 0x6A, 0x21, 0x3C, 0x5E, 0x3E, 0x76, 0x2D, 0x76, 0x4C, 0x2D, 0x2D, 0x4C, 0x2D, 0x2B, 0x2B,
+			0x54, 0x2B, 0x2B, 0x3D, 0x2D, 0x4C, 0x4C, 0x4C, 0x2D, 0x2D, 0x2D, 0x54, 0x54, 0x54, 0x2B, 0x2B,
+			0x2B, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x5E, 0x3E, 0x3C, 0x30, 0x30, 0x4F, 0x4F, 0x30,
+			0x2B, 0x3E, 0x64, 0x64, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C,
+			0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C,
+			0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C,
+			0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C,
+			0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
+			0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
+			0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1252",
+		from: []rune{
+			0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107, 0x0108, 0x0109,
+			0x010A, 0x010B, 0x010C, 0x010D, 0x010E, 0x010F, 0x0111, 0x0112, 0x0113, 0x0114,
+			0x0115, 0x0116, 0x0117, 0x0118, 0x0119, 0x011A, 0x011B, 0x011C, 0x011D, 0x011E,
+			0x011F, 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, 0x0126, 0x0127, 0x0128,
+			0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E, 0x012F, 0x0130, 0x0131, 0x0134,
+			0x0135, 0x0136, 0x0137, 0x0139, 0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0141,
+			0x0142, 0x0143, 0x0144, 0x0145, 0x0146, 0x0147, 0x0148, 0x014C, 0x014D, 0x014E,
+			0x014F, 0x0150, 0x0151, 0x0154, 0x0155, 0x0156, 0x0157, 0x0158, 0x0159, 0x015A,
+			0x015B, 0x015C, 0x015D, 0x015E, 0x015F, 0x0162, 0x0163, 0x0164, 0x0165, 0x0166,
+			0x0167, 0x0168, 0x0169, 0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F, 0x0170,
+			0x0171, 0x0172, 0x0173, 0x0174, 0x0175, 0x0176, 0x0177, 0x0179, 0x017A, 0x017B,
+			0x017C, 0x0180, 0x0197, 0x019A, 0x019F, 0x01A0, 0x01A1, 0x01AB, 0x01AE, 0x01AF,
+			0x01B0, 0x01B6, 0x01C0, 0x01C3, 0x01CD, 0x01CE, 0x01CF, 0x01D0, 0x01D1, 0x01D2,
+			0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC,
+			0x01DE, 0x01DF, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB,
+			0x01EC, 0x01ED, 0x01F0, 0x0261, 0x02B9, 0x02BA, 0x02BC, 0x02C4, 0x02C8, 0x02CB,
+			0x02CD, 0x0300, 0x0302, 0x0303, 0x030E, 0x0331, 0x0332, 0x037E, 0x0393, 0x0398,
+			0x03A3, 0x03A6, 0x03A9, 0x03B1, 0x03B4, 0x03B5, 0x03C0, 0x03C3, 0x03C4, 0x03C6,
+			0x04BB, 0x0589, 0x066A, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006,
+			0x2010, 0x2011, 0x2017, 0x2032, 0x2035, 0x2044, 0x2074, 0x2075, 0x2076, 0x2077,
+			0x2078, 0x207F, 0x2080, 0x2081, 0x2082, 0x2083, 0x2084, 0x2085, 0x2086, 0x2087,
+			0x2088, 0x2089, 0x20A7, 0x2102, 0x2107, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E,
+			0x2110, 0x2111, 0x2112, 0x2113, 0x2115, 0x2118, 0x2119, 0x211A, 0x211B, 0x211C,
+			0x211D, 0x2124, 0x2128, 0x212A, 0x212C, 0x212D, 0x212E, 0x212F, 0x2130, 0x2131,
+			0x2133, 0x2134, 0x2212, 0x2215, 0x2216, 0x2217, 0x221A, 0x221E, 0x2223, 0x2229,
+			0x2236, 0x223C, 0x2261, 0x2264, 0x2265, 0x2303, 0x2320, 0x2321, 0x2329, 0x232A,
+			0x2500, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x252C, 0x2534, 0x253C, 0x2550,
+			0x2552, 0x2553, 0x2554, 0x2555, 0x2556, 0x2557, 0x2558, 0x2559, 0x255A, 0x255B,
+			0x255C, 0x255D, 0x2564, 0x2565, 0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B,
+			0x256C, 0x2584, 0x2758, 0x3000, 0x3008, 0x3009, 0x301A, 0x301B, 0xFF01, 0xFF02,
+			0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C,
+			0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16,
+			0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F, 0xFF20,
+			0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A,
+			0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34,
+			0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E,
+			0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48,
+			0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52,
+			0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C,
+			0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x41, 0x61, 0x41, 0x61, 0x41, 0x61, 0x43, 0x63, 0x43, 0x63, 0x43, 0x63, 0x43, 0x63, 0x44, 0x64,
+			0x64, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x47, 0x67, 0x47, 0x67, 0x47,
+			0x67, 0x47, 0x67, 0x48, 0x68, 0x48, 0x68, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49,
+			0x69, 0x4A, 0x6A, 0x4B, 0x6B, 0x4C, 0x6C, 0x4C, 0x6C, 0x4C, 0x6C, 0x4C, 0x6C, 0x4E, 0x6E, 0x4E,
+			0x6E, 0x4E, 0x6E, 0x4F, 0x6F, 0x4F, 0x6F, 0x4F, 0x6F, 0x52, 0x72, 0x52, 0x72, 0x52, 0x72, 0x53,
+			0x73, 0x53, 0x73, 0x53, 0x73, 0x54, 0x74, 0x54, 0x74, 0x54, 0x74, 0x55, 0x75, 0x55, 0x75, 0x55,
+			0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x57, 0x77, 0x59, 0x79, 0x5A, 0x7A, 0x5A, 0x7A, 0x62,
+			0x49, 0x6C, 0x4F, 0x4F, 0x6F, 0x74, 0x54, 0x55, 0x75, 0x7A, 0x7C, 0x21, 0x41, 0x61, 0x49, 0x69,
+			0x4F, 0x6F, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x41, 0x61, 0x47, 0x67,
+			0x47, 0x67, 0x4B, 0x6B, 0x4F, 0x6F, 0x4F, 0x6F, 0x6A, 0x67, 0x27, 0x22, 0x27, 0x5E, 0x27, 0x60,
+			0x5F, 0x60, 0x5E, 0x7E, 0x22, 0x5F, 0x5F, 0x3B, 0x47, 0x54, 0x53, 0x46, 0x4F, 0x61, 0x64, 0x65,
+			0x70, 0x73, 0x74, 0x66, 0x68, 0x3A, 0x25, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2D, 0x2D,
+			0x3D, 0x27, 0x60, 0x2F, 0x34, 0x35, 0x36, 0x37, 0x38, 0x6E, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+			0x36, 0x37, 0x38, 0x39, 0x50, 0x43, 0x45, 0x67, 0x48, 0x48, 0x48, 0x68, 0x49, 0x49, 0x4C, 0x6C,
+			0x4E, 0x50, 0x50, 0x51, 0x52, 0x52, 0x52, 0x5A, 0x5A, 0x4B, 0x42, 0x43, 0x65, 0x65, 0x45, 0x46,
+			0x4D, 0x6F, 0x2D, 0x2F, 0x5C, 0x2A, 0x76, 0x38, 0x7C, 0x6E, 0x3A, 0x7E, 0x3D, 0x3D, 0x3D, 0x5E,
+			0x28, 0x29, 0x3C, 0x3E, 0x2D, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2D, 0x2D, 0x2B, 0x2D, 0x2B, 0x2B,
+			0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D,
+			0x2B, 0x2B, 0x2B, 0x5F, 0x7C, 0x20, 0x3C, 0x3E, 0x5B, 0x5D, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
+			0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+			0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+			0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
+			0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+			0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
+			0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1253",
+		from: []rune{
+			0x00B4, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C7, 0x00C8, 0x00C9,
+			0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D1, 0x00D2, 0x00D3, 0x00D4,
+			0x00D5, 0x00D6, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00E0, 0x00E1,
+			0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC,
+			0x00ED, 0x00EE, 0x00EF, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F8,
+			0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FF, 0x0100, 0x0101, 0x0102, 0x0103,
+			0x0104, 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D,
+			0x010E, 0x010F, 0x0110, 0x0111, 0x0112, 0x0113, 0x0114, 0x0115, 0x0116, 0x0117,
+			0x0118, 0x0119, 0x011A, 0x011B, 0x011C, 0x011D, 0x011E, 0x011F, 0x0120, 0x0121,
+			0x0122, 0x0123, 0x0124, 0x0125, 0x0126, 0x0127, 0x0128, 0x0129, 0x012A, 0x012B,
+			0x012C, 0x012D, 0x012E, 0x012F, 0x0130, 0x0134, 0x0135, 0x0136, 0x0137, 0x0139,
+			0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0141, 0x0142, 0x0143, 0x0144, 0x0145,
+			0x0146, 0x0147, 0x0148, 0x014C, 0x014D, 0x014E, 0x014F, 0x0150, 0x0151, 0x0154,
+			0x0155, 0x0156, 0x0157, 0x0158, 0x0159, 0x015A, 0x015B, 0x015C, 0x015D, 0x015E,
+			0x015F, 0x0160, 0x0161, 0x0162, 0x0163, 0x0164, 0x0165, 0x0166, 0x0167, 0x0168,
+			0x0169, 0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F, 0x0170, 0x0171, 0x0172,
+			0x0173, 0x0174, 0x0175, 0x0176, 0x0177, 0x0178, 0x0179, 0x017A, 0x017B, 0x017C,
+			0x017D, 0x017E, 0x0180, 0x0197, 0x019A, 0x019F, 0x01A0, 0x01A1, 0x01AB, 0x01AE,
+			0x01AF, 0x01B0, 0x01CD, 0x01CE, 0x01CF, 0x01D0, 0x01D1, 0x01D2, 0x01D3, 0x01D4,
+			0x01D5, 0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC, 0x01DE, 0x01DF,
+			0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED,
+			0x01F0, 0x037E, 0x203C, 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x221F, 0x2500,
+			0x250C, 0x2514, 0x2518, 0x251C, 0x2524, 0x252C, 0x2534, 0x253C, 0x2550, 0x2554,
+			0x255A, 0x255D, 0x2566, 0x256C, 0x2580, 0x2584, 0x2588, 0x2591, 0x2592, 0x2593,
+			0x25AC, 0x25B2, 0x25BA, 0x25C4, 0x25CB, 0x25D9, 0x263A, 0x263B, 0x263C, 0x2640,
+			0x2642, 0x266A, 0x266B, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07,
+			0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11,
+			0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B,
+			0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25,
+			0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F,
+			0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39,
+			0xFF3A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43,
+			0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D,
+			0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57,
+			0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x2F, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x43, 0x45, 0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
+			0x4E, 0x4F, 0x4F, 0x4F, 0x4F, 0x4F, 0x4F, 0x55, 0x55, 0x55, 0x55, 0x59, 0x61, 0x61, 0x61, 0x61,
+			0x61, 0x61, 0x63, 0x65, 0x65, 0x65, 0x65, 0x69, 0x69, 0x69, 0x69, 0x6E, 0x6F, 0x6F, 0x6F, 0x6F,
+			0x6F, 0x6F, 0x75, 0x75, 0x75, 0x75, 0x79, 0x79, 0x41, 0x61, 0x41, 0x61, 0x41, 0x61, 0x43, 0x63,
+			0x43, 0x63, 0x43, 0x63, 0x43, 0x63, 0x44, 0x64, 0x44, 0x64, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65,
+			0x45, 0x65, 0x45, 0x65, 0x47, 0x67, 0x47, 0x67, 0x47, 0x67, 0x47, 0x67, 0x48, 0x68, 0x48, 0x68,
+			0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x4A, 0x6A, 0x4B, 0x6B, 0x4C, 0x6C, 0x4C,
+			0x6C, 0x4C, 0x6C, 0x4C, 0x6C, 0x4E, 0x6E, 0x4E, 0x6E, 0x4E, 0x6E, 0x4F, 0x6F, 0x4F, 0x6F, 0x4F,
+			0x6F, 0x52, 0x72, 0x52, 0x72, 0x52, 0x72, 0x53, 0x73, 0x53, 0x73, 0x53, 0x73, 0x53, 0x73, 0x54,
+			0x74, 0x54, 0x74, 0x54, 0x74, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55,
+			0x75, 0x57, 0x77, 0x59, 0x79, 0x59, 0x5A, 0x7A, 0x5A, 0x7A, 0x5A, 0x7A, 0x62, 0x49, 0x6C, 0x4F,
+			0x4F, 0x6F, 0x74, 0x54, 0x55, 0x75, 0x41, 0x61, 0x49, 0x69, 0x4F, 0x6F, 0x55, 0x75, 0x55, 0x75,
+			0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x41, 0x61, 0x47, 0x67, 0x47, 0x67, 0x4B, 0x6B, 0x4F, 0x6F,
+			0x4F, 0x6F, 0x6A, 0x3B, 0x21, 0x3C, 0x5E, 0x3E, 0x76, 0x2D, 0x4C, 0x2D, 0x2D, 0x4C, 0x2D, 0x2B,
+			0x2B, 0x54, 0x2B, 0x2B, 0x3D, 0x2D, 0x4C, 0x2D, 0x54, 0x2B, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D,
+			0x2D, 0x5E, 0x3E, 0x3C, 0x30, 0x30, 0x4F, 0x4F, 0x30, 0x2B, 0x3E, 0x64, 0x64, 0x21, 0x22, 0x23,
+			0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33,
+			0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43,
+			0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53,
+			0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63,
+			0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73,
+			0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1254",
+		from: []rune{
+			0x00DD, 0x00FD, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107,
+			0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D, 0x010E, 0x010F, 0x0110, 0x0111,
+			0x0112, 0x0113, 0x0114, 0x0115, 0x0116, 0x0117, 0x0118, 0x0119, 0x011A, 0x011B,
+			0x011C, 0x011D, 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, 0x0126, 0x0127,
+			0x0128, 0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E, 0x012F, 0x0134, 0x0135,
+			0x0136, 0x0137, 0x0139, 0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0141, 0x0142,
+			0x0143, 0x0144, 0x0145, 0x0146, 0x0147, 0x0148, 0x014C, 0x014D, 0x014E, 0x014F,
+			0x0150, 0x0151, 0x0154, 0x0155, 0x0156, 0x0157, 0x0158, 0x0159, 0x015A, 0x015B,
+			0x015C, 0x015D, 0x0162, 0x0163, 0x0164, 0x0165, 0x0166, 0x0167, 0x0168, 0x0169,
+			0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F, 0x0170, 0x0171, 0x0172, 0x0173,
+			0x0174, 0x0175, 0x0176, 0x0177, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D, 0x017E,
+			0x0180, 0x0189, 0x0197, 0x019A, 0x019F, 0x01A0, 0x01A1, 0x01AB, 0x01AE, 0x01AF,
+			0x01B0, 0x01B6, 0x01C0, 0x01C3, 0x01CD, 0x01CE, 0x01CF, 0x01D0, 0x01D1, 0x01D2,
+			0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC,
+			0x01DE, 0x01DF, 0x01E4, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB,
+			0x01EC, 0x01ED, 0x01F0, 0x0261, 0x02B9, 0x02BA, 0x02BC, 0x02C4, 0x02C7, 0x02C8,
+			0x02CB, 0x02CD, 0x02D8, 0x02D9, 0x0300, 0x0302, 0x0331, 0x0332, 0x04BB, 0x0589,
+			0x066A, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2010, 0x2011,
+			0x2032, 0x2035, 0x203C, 0x2044, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2081,
+			0x2084, 0x2085, 0x2086, 0x2087, 0x2088, 0x2089, 0x2102, 0x2107, 0x210A, 0x210B,
+			0x210C, 0x210D, 0x210E, 0x2110, 0x2111, 0x2112, 0x2113, 0x2115, 0x2118, 0x2119,
+			0x211A, 0x211B, 0x211C, 0x211D, 0x2124, 0x2128, 0x212A, 0x212C, 0x212D, 0x212E,
+			0x212F, 0x2130, 0x2131, 0x2133, 0x2134, 0x2191, 0x2193, 0x2194, 0x2195, 0x21A8,
+			0x2212, 0x2215, 0x2216, 0x2217, 0x221F, 0x2223, 0x2236, 0x223C, 0x2303, 0x2329,
+			0x232A, 0x2502, 0x250C, 0x2514, 0x2518, 0x251C, 0x2524, 0x252C, 0x2534, 0x253C,
+			0x2550, 0x2554, 0x255A, 0x255D, 0x2566, 0x256C, 0x2580, 0x2584, 0x2588, 0x2591,
+			0x2592, 0x2593, 0x25AC, 0x25B2, 0x25BA, 0x25C4, 0x25CB, 0x25D9, 0x263A, 0x263B,
+			0x263C, 0x2640, 0x2642, 0x266A, 0x266B, 0x2758, 0x3000, 0x3008, 0x3009, 0x301A,
+			0x301B, 0x301D, 0x301E, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07,
+			0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11,
+			0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B,
+			0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25,
+			0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F,
+			0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39,
+			0xFF3A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43,
+			0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D,
+			0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57,
+			0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x59, 0x79, 0x41, 0x61, 0x41, 0x61, 0x41, 0x61, 0x43, 0x63, 0x43, 0x63, 0x43, 0x63, 0x43, 0x63,
+			0x44, 0x64, 0x44, 0x64, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x45, 0x65, 0x47, 0x67,
+			0x47, 0x67, 0x47, 0x67, 0x48, 0x68, 0x48, 0x68, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69, 0x49, 0x69,
+			0x4A, 0x6A, 0x4B, 0x6B, 0x4C, 0x6C, 0x4C, 0x6C, 0x4C, 0x6C, 0x4C, 0x6C, 0x4E, 0x6E, 0x4E, 0x6E,
+			0x4E, 0x6E, 0x4F, 0x6F, 0x4F, 0x6F, 0x4F, 0x6F, 0x52, 0x72, 0x52, 0x72, 0x52, 0x72, 0x53, 0x73,
+			0x53, 0x73, 0x54, 0x74, 0x54, 0x74, 0x54, 0x74, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75,
+			0x55, 0x75, 0x55, 0x75, 0x57, 0x77, 0x59, 0x79, 0x5A, 0x7A, 0x5A, 0x7A, 0x5A, 0x7A, 0x62, 0x44,
+			0x49, 0x6C, 0x4F, 0x4F, 0x6F, 0x74, 0x54, 0x55, 0x75, 0x7A, 0x7C, 0x21, 0x41, 0x61, 0x49, 0x69,
+			0x4F, 0x6F, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x55, 0x75, 0x41, 0x61, 0x47, 0x67,
+			0x47, 0x67, 0x4B, 0x6B, 0x4F, 0x6F, 0x4F, 0x6F, 0x6A, 0x67, 0x27, 0x22, 0x27, 0x5E, 0x5E, 0x27,
+			0x60, 0x5F, 0x5E, 0x27, 0x60, 0x5E, 0x5F, 0x5F, 0x68, 0x3A, 0x25, 0x20, 0x20, 0x20, 0x20, 0x20,
+			0x20, 0x20, 0x2D, 0x2D, 0x27, 0x60, 0x21, 0x2F, 0x34, 0x35, 0x36, 0x37, 0x38, 0x30, 0x34, 0x35,
+			0x36, 0x37, 0x38, 0x39, 0x43, 0x45, 0x67, 0x48, 0x48, 0x48, 0x68, 0x49, 0x49, 0x4C, 0x6C, 0x4E,
+			0x50, 0x50, 0x51, 0x52, 0x52, 0x52, 0x5A, 0x5A, 0x4B, 0x42, 0x43, 0x65, 0x65, 0x45, 0x46, 0x4D,
+			0x6F, 0x5E, 0x76, 0x2D, 0x7C, 0x7C, 0x2D, 0x2F, 0x5C, 0x2A, 0x4C, 0x7C, 0x3A, 0x7E, 0x5E, 0x3C,
+			0x3E, 0x2D, 0x2D, 0x4C, 0x2D, 0x2B, 0x2B, 0x54, 0x2B, 0x2B, 0x3D, 0x2D, 0x4C, 0x2D, 0x54, 0x2B,
+			0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x5E, 0x3E, 0x3C, 0x30, 0x30, 0x4F, 0x4F, 0x30, 0x2B,
+			0x3E, 0x64, 0x64, 0x7C, 0x20, 0x3C, 0x3E, 0x5B, 0x3D, 0x22, 0x22, 0x21, 0x22, 0x23, 0x24, 0x25,
+			0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+			0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
+			0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
+			0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65,
+			0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
+			0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1255",
+		from: []rune{
+			0x0191, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09,
+			0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13,
+			0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D,
+			0xFF1E, 0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27,
+			0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31,
+			0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B,
+			0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45,
+			0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F,
+			0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59,
+			0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x46, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
+			0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
+			0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
+			0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
+			0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
+			0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1256",
+		from: []rune{
+			0x00C0, 0x00C2, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CE, 0x00CF, 0x00D4,
+			0x00D9, 0x00DB, 0x00DC, 0x0191, 0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665,
+			0x0666, 0x0667, 0x0668, 0x0669, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06,
+			0xFF07, 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10,
+			0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A,
+			0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24,
+			0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E,
+			0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38,
+			0xFF39, 0xFF3A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42,
+			0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C,
+			0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56,
+			0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x41, 0x41, 0x43, 0x45, 0x45, 0x45, 0x45, 0x49, 0x49, 0x4F, 0x55, 0x55, 0x55, 0x46, 0x30, 0x31,
+			0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+			0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
+			0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+			0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+			0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+			0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+			0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1257",
+		from: []rune{
+			0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A,
+			0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14,
+			0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E,
+			0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28,
+			0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32,
+			0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B, 0xFF3C,
+			0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46,
+			0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50,
+			0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A,
+			0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
+			0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40,
+			0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+			0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60,
+			0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
+			0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1258",
+		from: []rune{
+			0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A,
+			0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14,
+			0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E,
+			0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28,
+			0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32,
+			0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B, 0xFF3C,
+			0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46,
+			0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50,
+			0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A,
+			0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E,
+		},
+		to: []byte{
+			0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
+			0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40,
+			0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+			0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60,
+			0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
+			0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
+		},
+	},
+	{
+		name: "1361",
+		from: []rune{
+			0x20A9,
+		},
+		to: []byte{
+			0x5C,
+		},
+	},
+}
diff --git a/internal/pathrule/unicode.go b/internal/pathrule/unicode.go
new file mode 100644
index 0000000..4b02be7
--- /dev/null
+++ b/internal/pathrule/unicode.go
@@ -0,0 +1,248 @@
+// Package pathrule checks the paths and the texts of the head of a format 3
+// capsule (spec §29.5, §29.6) with fixed Unicode 18.0.0 and WindowsBestFit
+// tables (spec §29.5.1), never with the Unicode functions of the platform,
+// whose version changes with each runtime: Go 1.26.8 carries Unicode 15.0.0,
+// and Node 24.9, 16.0.
+//
+// The tables are generated by internal/pathrule/gen; see tables.go.
+package pathrule
+
+//go:generate go run ./gen -data ../../.cache -go tables.go
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"slices"
+	"strings"
+)
+
+// mapping is a sorted table from a code point to a sequence of code points:
+// the value of keys[i] is data[start[i]:start[i+1]].
+type mapping struct {
+	keys  []rune
+	start []uint16
+	data  []rune
+}
+
+func (m *mapping) lookup(r rune) ([]rune, bool) {
+	i, ok := slices.BinarySearch(m.keys, r)
+	if !ok {
+		return nil, false
+	}
+	return m.data[m.start[i]:m.start[i+1]], true
+}
+
+// bestFitTable is one code page of WindowsBestFit, reduced to the non-ASCII
+// code points it maps to an ASCII byte.
+type bestFitTable struct {
+	name string
+	from []rune
+	to   []byte
+}
+
+func (t *bestFitTable) lookup(r rune) (byte, bool) {
+	i, ok := slices.BinarySearch(t.from, r)
+	if !ok {
+		return 0, false
+	}
+	return t.to[i], true
+}
+
+// inRanges reports whether r lies in one of the inclusive ranges lo, hi, ...
+func inRanges(ranges []rune, r rune) bool {
+	// The first range whose hi is >= r.
+	lo, hi := 0, len(ranges)/2
+	for lo < hi {
+		m := int(uint(lo+hi) >> 1)
+		if ranges[2*m+1] < r {
+			lo = m + 1
+		} else {
+			hi = m
+		}
+	}
+	return lo < len(ranges)/2 && ranges[2*lo] <= r
+}
+
+// Assigned reports whether r is an assigned code point of Unicode 18.0.0: a
+// code point that is not of general category Cn.
+func Assigned(r rune) bool { return inRanges(assignedRanges, r) }
+
+// DefaultIgnorable reports whether r has the property
+// Default_Ignorable_Code_Point in Unicode 18.0.0.
+func DefaultIgnorable(r rune) bool { return inRanges(ignorableRanges, r) }
+
+// ccc is the canonical combining class of r.
+func ccc(r rune) uint8 {
+	i, ok := slices.BinarySearchFunc(cccTable, r, func(e uint32, r rune) int {
+		switch c := rune(e >> 8); {
+		case c < r:
+			return -1
+		case c > r:
+			return 1
+		}
+		return 0
+	})
+	if !ok {
+		return 0
+	}
+	return uint8(cccTable[i])
+}
+
+// Hangul syllable decomposition (Unicode §3.12).
+const (
+	hangulS = 0xAC00
+	hangulL = 0x1100
+	hangulV = 0x1161
+	hangulT = 0x11A7
+	hangulN = 21 * 28
+	hangulC = 19 * hangulN
+)
+
+// NFD returns the canonical decomposition of s, normalization form D of UAX
+// #15 with the data of Unicode 18.0.0: every code point replaced by its full
+// canonical decomposition, Hangul syllables decomposed algorithmically, and
+// each run of combining marks put in canonical order, a stable sort by
+// canonical combining class.
+func NFD(s string) string {
+	var out []rune
+	for _, r := range s {
+		switch {
+		case r >= hangulS && r < hangulS+hangulC:
+			i := r - hangulS
+			out = append(out, hangulL+i/hangulN, hangulV+(i%hangulN)/28)
+			if t := i % 28; t != 0 {
+				out = append(out, hangulT+t)
+			}
+		default:
+			if d, ok := decompositions.lookup(r); ok {
+				out = append(out, d...)
+			} else {
+				out = append(out, r)
+			}
+		}
+	}
+	// Canonical ordering: insertion sort within each run of non-starters,
+	// stable, by combining class.
+	for i := 1; i < len(out); i++ {
+		c := ccc(out[i])
+		if c == 0 {
+			continue
+		}
+		for j := i; j > 0; j-- {
+			p := ccc(out[j-1])
+			if p <= c {
+				break
+			}
+			out[j-1], out[j] = out[j], out[j-1]
+		}
+	}
+	return string(out)
+}
+
+// Fold returns the case folding of s: the mappings of CaseFolding.txt with
+// status C or F, and U+0131 (ı) to U+0069 (i), as NTFS does (spec §29.5, R7).
+func Fold(s string) string {
+	var b strings.Builder
+	for _, r := range s {
+		if r == 0x0131 {
+			b.WriteRune(0x0069)
+		} else if f, ok := foldings.lookup(r); ok {
+			for _, x := range f {
+				b.WriteRune(x)
+			}
+		} else {
+			b.WriteRune(r)
+		}
+	}
+	return b.String()
+}
+
+// The whitelist of R4: the Default_Ignorable_Code_Point that a path may hold
+// (spec §29.5).
+const (
+	zwnj = 0x200C
+	zwj  = 0x200D
+	vs15 = 0xFE0E
+	vs16 = 0xFE0F
+)
+
+func whitelisted(r rune) bool { return r == zwnj || r == zwj || r == vs15 || r == vs16 }
+
+// stripWhitelist removes the whitelisted code points of R4 from s.
+func stripWhitelist(s string) string {
+	return strings.Map(func(r rune) rune {
+		if whitelisted(r) {
+			return -1
+		}
+		return r
+	}, s)
+}
+
+// Key is the key of a segment in R7: NFD(fold(NFD(s′))), where s′ is the
+// segment without the whitelisted code points of R4. They are removed
+// before normalizing because they have combining class 0: between two
+// combining marks, they would change their canonical order.
+func Key(segment string) string {
+	return NFD(Fold(NFD(stripWhitelist(segment))))
+}
+
+// allowsSelector reports whether base forms an emoji variation sequence with
+// the selector sel, U+FE0E or U+FE0F (R4b).
+func allowsSelector(base, sel rune) bool {
+	bases := vs16Bases
+	if sel == vs15 {
+		bases = vs15Bases
+	}
+	_, ok := slices.BinarySearch(bases, base)
+	return ok
+}
+
+// Canonical is the canonical text of the tables, whose SHA-256 is
+// TablesDigest; the generator writes the same text from the data files. Each
+// value is in upper-case hexadecimal of at least four digits, except the
+// combining class and the code page, in decimal, and the best-fit byte, in
+// two hexadecimal digits.
+func Canonical() string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "unicode %s\n", UnicodeVersion)
+	for i := 0; i < len(assignedRanges); i += 2 {
+		fmt.Fprintf(&b, "assigned %04X %04X\n", assignedRanges[i], assignedRanges[i+1])
+	}
+	for i := 0; i < len(ignorableRanges); i += 2 {
+		fmt.Fprintf(&b, "ignorable %04X %04X\n", ignorableRanges[i], ignorableRanges[i+1])
+	}
+	for _, e := range cccTable {
+		fmt.Fprintf(&b, "ccc %04X %d\n", e>>8, e&0xFF)
+	}
+	for _, m := range []struct {
+		name string
+		t    *mapping
+	}{{"decomp", &decompositions}, {"fold", &foldings}} {
+		for i, k := range m.t.keys {
+			fmt.Fprintf(&b, "%s %04X", m.name, k)
+			for _, r := range m.t.data[m.t.start[i]:m.t.start[i+1]] {
+				fmt.Fprintf(&b, " %04X", r)
+			}
+			b.WriteByte('\n')
+		}
+	}
+	for _, r := range vs15Bases {
+		fmt.Fprintf(&b, "vs15 %04X\n", r)
+	}
+	for _, r := range vs16Bases {
+		fmt.Fprintf(&b, "vs16 %04X\n", r)
+	}
+	for _, t := range bestFitTables {
+		for i, r := range t.from {
+			fmt.Fprintf(&b, "bestfit %s %04X %02X\n", t.name, r, t.to[i])
+		}
+	}
+	return b.String()
+}
+
+// digest is the SHA-256 of Canonical, in hexadecimal.
+func digest() string {
+	sum := sha256.Sum256([]byte(Canonical()))
+	return hex.EncodeToString(sum[:])
+}
diff --git a/spec/DateKeys_Protocol_Specification_v0.10.md b/spec/DateKeys_Protocol_Specification_v0.10.md
index 940edba..79731ae 100644
--- a/spec/DateKeys_Protocol_Specification_v0.10.md
+++ b/spec/DateKeys_Protocol_Specification_v0.10.md
@@ -1189,7 +1189,29 @@ R3, R4, R4b, R6c, R7 y la regla de invisibles de §29.6 usan datos fijos, no los
 - **Unicode 18.0.0:** `UnicodeData.txt`, con la categoría general, la clase de combinación canónica y las descomposiciones canónicas; `DerivedCoreProperties.txt`, con `Default_Ignorable_Code_Point`; `CaseFolding.txt`, con sus entradas C y F; `emoji/emoji-variation-sequences.txt`, con los caracteres que admiten VS15 y VS16 (R4b); y NFD según UAX #15, con la descomposición algorítmica de Hangul.
 - **WindowsBestFit,** de unicode.org: los quince ficheros `bestfit874.txt`, `bestfit932.txt`, `bestfit936.txt`, `bestfit949.txt`, `bestfit950.txt`, de `bestfit1250.txt` a `bestfit1258.txt` y `bestfit1361.txt`, con la conversión de Unicode a su código de página de su sección `WCTABLE`.
 
-Una implementación MUST aplicar las tablas generadas de esos ficheros, fijados por su SHA-256 (por fijar al implementar), y MUST NOT usar las funciones de Unicode de su plataforma para estas reglas: `normalize`, `toLowerCase`, las clases `\p{…}` de las expresiones regulares, el paquete `unicode` de Go o `golang.org/x/text`. Su versión de Unicode cambia con cada motor: Go 1.26.8 trae la 15.0.0, y Node 24.9, la 16.0. La implementación de referencia genera desde esos ficheros el código de las dos implementaciones, y sus pruebas comprueban los digests.
+Una implementación MUST aplicar las tablas generadas de esos ficheros, fijados por el SHA-256 de la tabla de abajo, y MUST NOT usar las funciones de Unicode de su plataforma para estas reglas: `normalize`, `toLowerCase`, las clases `\p{…}` de las expresiones regulares, el paquete `unicode` de Go o `golang.org/x/text`. Su versión de Unicode cambia con cada motor: Go 1.26.8 trae la 15.0.0, y Node 24.9, la 16.0. La implementación de referencia genera desde esos ficheros el código de las dos implementaciones, y sus pruebas comprueban los digests. Las rutas de la tabla son las de los ficheros bajo `https://www.unicode.org/Public/18.0.0/ucd/` y `https://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/`.
+
+| Fichero | SHA-256 |
+|---|---|
+| `unicode/18.0.0/UnicodeData.txt` | `0736451de439ae7baf1425136617da495e09ee5afbe6e394374db7009ea08950` |
+| `unicode/18.0.0/DerivedCoreProperties.txt` | `09c928886a178fcafd93c29e4bd59073a058e5a100b716d425cb563ab50f68c9` |
+| `unicode/18.0.0/CaseFolding.txt` | `a004797658a457bec4dc11683e39f69249ea3b595b752dbea6721c4c9f587b0d` |
+| `unicode/18.0.0/emoji/emoji-variation-sequences.txt` | `ff1707564aa1f1b2fcf4ec92d609d4cb26940bc0d4dcf07f5328ad6879e84da3` |
+| `bestfit/bestfit874.txt` | `663f43ca662e037c4534cb16298b560f29ce29c27b49b3589601ec3d97dd89fd` |
+| `bestfit/bestfit932.txt` | `2614cfea35c3c86c41d33198793a84ca44edee3cf0ee0013a61a43fba4ece331` |
+| `bestfit/bestfit936.txt` | `e5070a2d6ad26619f5872ddbe64d3381c11620af5adbb04cda0f0abb1a91fdae` |
+| `bestfit/bestfit949.txt` | `50e13b60ea8fda66a8223ecc85270e0f182303222244e2345d3d57f3e839d20a` |
+| `bestfit/bestfit950.txt` | `cf8c23389a42a226ea707f7ec32c665556d1fc3364db25bd765ce64d54eaee2a` |
+| `bestfit/bestfit1250.txt` | `cef9f171e67b09445bcb3f9ffccdc89418250ff825f1bd2d29a92d2074d7a53b` |
+| `bestfit/bestfit1251.txt` | `59ec85612ff908d9da0e877893c935941e56b13a2882b4fb9c9599be3d1ce4e7` |
+| `bestfit/bestfit1252.txt` | `72ea23c939c5b26fae7aded0207b327e2f3902d7d3c168d7087f5cfc38ee76a9` |
+| `bestfit/bestfit1253.txt` | `ea80c442aff7f09b36da6335f85f8e527f51c146beeb9825ec00d1b6ca99a99e` |
+| `bestfit/bestfit1254.txt` | `3d02512087634dc493b720992b590277736ffb2d5b0b665d69b6b9727e2c361a` |
+| `bestfit/bestfit1255.txt` | `fdd4bdda74f6571d89171b0070ac052cd3714c395dc3d1799bcd5e4a4da6f83a` |
+| `bestfit/bestfit1256.txt` | `745c447ada04a838da8bea406c13f446c7453b6371e8c6c7863a632443d56007` |
+| `bestfit/bestfit1257.txt` | `b8c5d7f3b8c25c3d5625d44dd3d6ee7a06e652ddf77373d050282c1cb7517366` |
+| `bestfit/bestfit1258.txt` | `5d52a9357b7d6b5b5014ed5a51be0ff9809b0c33625793d2a4feaf502e0682f1` |
+| `bestfit/bestfit1361.txt` | `7dcda2d5d2cfc5ddf43757d589a0106e020ef0d9b84de47f08e18297ae0fe1ec` |
 
 Un punto de código posterior a Unicode 18.0.0 es Cn para estas tablas: R4 lo rechaza, y el escritor lo dice con un mensaje que nombra el carácter (§62.1, regla 15).