summaryrefslogtreecommitdiff
path: root/src/pkg/exp
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/exp')
-rw-r--r--src/pkg/exp/norm/Makefile30
-rw-r--r--src/pkg/exp/norm/composition.go382
-rw-r--r--src/pkg/exp/norm/composition_test.go143
-rw-r--r--src/pkg/exp/norm/example_iter_test.go81
-rw-r--r--src/pkg/exp/norm/forminfo.go229
-rw-r--r--src/pkg/exp/norm/input.go105
-rw-r--r--src/pkg/exp/norm/iter.go401
-rw-r--r--src/pkg/exp/norm/iter_test.go188
-rw-r--r--src/pkg/exp/norm/maketables.go923
-rw-r--r--src/pkg/exp/norm/maketesttables.go45
-rw-r--r--src/pkg/exp/norm/norm_test.go14
-rw-r--r--src/pkg/exp/norm/normalize.go478
-rw-r--r--src/pkg/exp/norm/normalize_test.go750
-rw-r--r--src/pkg/exp/norm/normregtest.go304
-rw-r--r--src/pkg/exp/norm/readwriter.go126
-rw-r--r--src/pkg/exp/norm/readwriter_test.go68
-rw-r--r--src/pkg/exp/norm/tables.go6779
-rw-r--r--src/pkg/exp/norm/trie.go232
-rw-r--r--src/pkg/exp/norm/trie_test.go152
-rw-r--r--src/pkg/exp/norm/triedata_test.go85
-rw-r--r--src/pkg/exp/norm/triegen.go317
21 files changed, 11832 insertions, 0 deletions
diff --git a/src/pkg/exp/norm/Makefile b/src/pkg/exp/norm/Makefile
new file mode 100644
index 000000000..f278eb02f
--- /dev/null
+++ b/src/pkg/exp/norm/Makefile
@@ -0,0 +1,30 @@
+# Copyright 2011 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+maketables: maketables.go triegen.go
+ go build $^
+
+maketesttables: maketesttables.go triegen.go
+ go build $^
+
+normregtest: normregtest.go
+ go build $^
+
+tables: maketables
+ ./maketables > tables.go
+ gofmt -w tables.go
+
+trietesttables: maketesttables
+ ./maketesttables > triedata_test.go
+ gofmt -w triedata_test.go
+
+# Downloads from www.unicode.org, so not part
+# of standard test scripts.
+test: testtables regtest
+
+testtables: maketables
+ ./maketables -test -tables=
+
+regtest: normregtest
+ ./normregtest
diff --git a/src/pkg/exp/norm/composition.go b/src/pkg/exp/norm/composition.go
new file mode 100644
index 000000000..2d52f99dc
--- /dev/null
+++ b/src/pkg/exp/norm/composition.go
@@ -0,0 +1,382 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import "unicode/utf8"
+
+const (
+ maxCombiningChars = 30
+ maxBufferSize = maxCombiningChars + 2 // +1 to hold starter +1 to hold CGJ
+ maxBackRunes = maxCombiningChars - 1
+ maxNFCExpansion = 3 // NFC(0x1D160)
+ maxNFKCExpansion = 18 // NFKC(0xFDFA)
+
+ maxByteBufferSize = utf8.UTFMax * maxBufferSize // 128
+)
+
+// reorderBuffer is used to normalize a single segment. Characters inserted with
+// insert are decomposed and reordered based on CCC. The compose method can
+// be used to recombine characters. Note that the byte buffer does not hold
+// the UTF-8 characters in order. Only the rune array is maintained in sorted
+// order. flush writes the resulting segment to a byte array.
+type reorderBuffer struct {
+ rune [maxBufferSize]Properties // Per character info.
+ byte [maxByteBufferSize]byte // UTF-8 buffer. Referenced by runeInfo.pos.
+ nrune int // Number of runeInfos.
+ nbyte uint8 // Number or bytes.
+ f formInfo
+
+ src input
+ nsrc int
+ tmpBytes input
+}
+
+func (rb *reorderBuffer) init(f Form, src []byte) {
+ rb.f = *formTable[f]
+ rb.src.setBytes(src)
+ rb.nsrc = len(src)
+}
+
+func (rb *reorderBuffer) initString(f Form, src string) {
+ rb.f = *formTable[f]
+ rb.src.setString(src)
+ rb.nsrc = len(src)
+}
+
+// reset discards all characters from the buffer.
+func (rb *reorderBuffer) reset() {
+ rb.nrune = 0
+ rb.nbyte = 0
+}
+
+// flush appends the normalized segment to out and resets rb.
+func (rb *reorderBuffer) flush(out []byte) []byte {
+ for i := 0; i < rb.nrune; i++ {
+ start := rb.rune[i].pos
+ end := start + rb.rune[i].size
+ out = append(out, rb.byte[start:end]...)
+ }
+ rb.reset()
+ return out
+}
+
+// flushCopy copies the normalized segment to buf and resets rb.
+// It returns the number of bytes written to buf.
+func (rb *reorderBuffer) flushCopy(buf []byte) int {
+ p := 0
+ for i := 0; i < rb.nrune; i++ {
+ runep := rb.rune[i]
+ p += copy(buf[p:], rb.byte[runep.pos:runep.pos+runep.size])
+ }
+ rb.reset()
+ return p
+}
+
+// insertOrdered inserts a rune in the buffer, ordered by Canonical Combining Class.
+// It returns false if the buffer is not large enough to hold the rune.
+// It is used internally by insert and insertString only.
+func (rb *reorderBuffer) insertOrdered(info Properties) bool {
+ n := rb.nrune
+ if n >= maxCombiningChars+1 {
+ return false
+ }
+ b := rb.rune[:]
+ cc := info.ccc
+ if cc > 0 {
+ // Find insertion position + move elements to make room.
+ for ; n > 0; n-- {
+ if b[n-1].ccc <= cc {
+ break
+ }
+ b[n] = b[n-1]
+ }
+ }
+ rb.nrune += 1
+ pos := uint8(rb.nbyte)
+ rb.nbyte += utf8.UTFMax
+ info.pos = pos
+ b[n] = info
+ return true
+}
+
+// insert inserts the given rune in the buffer ordered by CCC.
+// It returns true if the buffer was large enough to hold the decomposed rune.
+func (rb *reorderBuffer) insert(src input, i int, info Properties) bool {
+ if rune := src.hangul(i); rune != 0 {
+ return rb.decomposeHangul(rune)
+ }
+ if info.hasDecomposition() {
+ return rb.insertDecomposed(info.Decomposition())
+ }
+ return rb.insertSingle(src, i, info)
+}
+
+// insertDecomposed inserts an entry in to the reorderBuffer for each rune
+// in dcomp. dcomp must be a sequence of decomposed UTF-8-encoded runes.
+func (rb *reorderBuffer) insertDecomposed(dcomp []byte) bool {
+ saveNrune, saveNbyte := rb.nrune, rb.nbyte
+ rb.tmpBytes.setBytes(dcomp)
+ for i := 0; i < len(dcomp); {
+ info := rb.f.info(rb.tmpBytes, i)
+ pos := rb.nbyte
+ if !rb.insertOrdered(info) {
+ rb.nrune, rb.nbyte = saveNrune, saveNbyte
+ return false
+ }
+ i += copy(rb.byte[pos:], dcomp[i:i+int(info.size)])
+ }
+ return true
+}
+
+// insertSingle inserts an entry in the reorderBuffer for the rune at
+// position i. info is the runeInfo for the rune at position i.
+func (rb *reorderBuffer) insertSingle(src input, i int, info Properties) bool {
+ // insertOrder changes nbyte
+ pos := rb.nbyte
+ if !rb.insertOrdered(info) {
+ return false
+ }
+ src.copySlice(rb.byte[pos:], i, i+int(info.size))
+ return true
+}
+
+// appendRune inserts a rune at the end of the buffer. It is used for Hangul.
+func (rb *reorderBuffer) appendRune(r rune) {
+ bn := rb.nbyte
+ sz := utf8.EncodeRune(rb.byte[bn:], rune(r))
+ rb.nbyte += utf8.UTFMax
+ rb.rune[rb.nrune] = Properties{pos: bn, size: uint8(sz)}
+ rb.nrune++
+}
+
+// assignRune sets a rune at position pos. It is used for Hangul and recomposition.
+func (rb *reorderBuffer) assignRune(pos int, r rune) {
+ bn := rb.rune[pos].pos
+ sz := utf8.EncodeRune(rb.byte[bn:], rune(r))
+ rb.rune[pos] = Properties{pos: bn, size: uint8(sz)}
+}
+
+// runeAt returns the rune at position n. It is used for Hangul and recomposition.
+func (rb *reorderBuffer) runeAt(n int) rune {
+ inf := rb.rune[n]
+ r, _ := utf8.DecodeRune(rb.byte[inf.pos : inf.pos+inf.size])
+ return r
+}
+
+// bytesAt returns the UTF-8 encoding of the rune at position n.
+// It is used for Hangul and recomposition.
+func (rb *reorderBuffer) bytesAt(n int) []byte {
+ inf := rb.rune[n]
+ return rb.byte[inf.pos : int(inf.pos)+int(inf.size)]
+}
+
+// For Hangul we combine algorithmically, instead of using tables.
+const (
+ hangulBase = 0xAC00 // UTF-8(hangulBase) -> EA B0 80
+ hangulBase0 = 0xEA
+ hangulBase1 = 0xB0
+ hangulBase2 = 0x80
+
+ hangulEnd = hangulBase + jamoLVTCount // UTF-8(0xD7A4) -> ED 9E A4
+ hangulEnd0 = 0xED
+ hangulEnd1 = 0x9E
+ hangulEnd2 = 0xA4
+
+ jamoLBase = 0x1100 // UTF-8(jamoLBase) -> E1 84 00
+ jamoLBase0 = 0xE1
+ jamoLBase1 = 0x84
+ jamoLEnd = 0x1113
+ jamoVBase = 0x1161
+ jamoVEnd = 0x1176
+ jamoTBase = 0x11A7
+ jamoTEnd = 0x11C3
+
+ jamoTCount = 28
+ jamoVCount = 21
+ jamoVTCount = 21 * 28
+ jamoLVTCount = 19 * 21 * 28
+)
+
+const hangulUTF8Size = 3
+
+func isHangul(b []byte) bool {
+ if len(b) < hangulUTF8Size {
+ return false
+ }
+ b0 := b[0]
+ if b0 < hangulBase0 {
+ return false
+ }
+ b1 := b[1]
+ switch {
+ case b0 == hangulBase0:
+ return b1 >= hangulBase1
+ case b0 < hangulEnd0:
+ return true
+ case b0 > hangulEnd0:
+ return false
+ case b1 < hangulEnd1:
+ return true
+ }
+ return b1 == hangulEnd1 && b[2] < hangulEnd2
+}
+
+func isHangulString(b string) bool {
+ if len(b) < hangulUTF8Size {
+ return false
+ }
+ b0 := b[0]
+ if b0 < hangulBase0 {
+ return false
+ }
+ b1 := b[1]
+ switch {
+ case b0 == hangulBase0:
+ return b1 >= hangulBase1
+ case b0 < hangulEnd0:
+ return true
+ case b0 > hangulEnd0:
+ return false
+ case b1 < hangulEnd1:
+ return true
+ }
+ return b1 == hangulEnd1 && b[2] < hangulEnd2
+}
+
+// Caller must ensure len(b) >= 2.
+func isJamoVT(b []byte) bool {
+ // True if (rune & 0xff00) == jamoLBase
+ return b[0] == jamoLBase0 && (b[1]&0xFC) == jamoLBase1
+}
+
+func isHangulWithoutJamoT(b []byte) bool {
+ c, _ := utf8.DecodeRune(b)
+ c -= hangulBase
+ return c < jamoLVTCount && c%jamoTCount == 0
+}
+
+// decomposeHangul writes the decomposed Hangul to buf and returns the number
+// of bytes written. len(buf) should be at least 9.
+func decomposeHangul(buf []byte, r rune) int {
+ const JamoUTF8Len = 3
+ r -= hangulBase
+ x := r % jamoTCount
+ r /= jamoTCount
+ utf8.EncodeRune(buf, jamoLBase+r/jamoVCount)
+ utf8.EncodeRune(buf[JamoUTF8Len:], jamoVBase+r%jamoVCount)
+ if x != 0 {
+ utf8.EncodeRune(buf[2*JamoUTF8Len:], jamoTBase+x)
+ return 3 * JamoUTF8Len
+ }
+ return 2 * JamoUTF8Len
+}
+
+// decomposeHangul algorithmically decomposes a Hangul rune into
+// its Jamo components.
+// See http://unicode.org/reports/tr15/#Hangul for details on decomposing Hangul.
+func (rb *reorderBuffer) decomposeHangul(r rune) bool {
+ b := rb.rune[:]
+ n := rb.nrune
+ if n+3 > len(b) {
+ return false
+ }
+ r -= hangulBase
+ x := r % jamoTCount
+ r /= jamoTCount
+ rb.appendRune(jamoLBase + r/jamoVCount)
+ rb.appendRune(jamoVBase + r%jamoVCount)
+ if x != 0 {
+ rb.appendRune(jamoTBase + x)
+ }
+ return true
+}
+
+// combineHangul algorithmically combines Jamo character components into Hangul.
+// See http://unicode.org/reports/tr15/#Hangul for details on combining Hangul.
+func (rb *reorderBuffer) combineHangul(s, i, k int) {
+ b := rb.rune[:]
+ bn := rb.nrune
+ for ; i < bn; i++ {
+ cccB := b[k-1].ccc
+ cccC := b[i].ccc
+ if cccB == 0 {
+ s = k - 1
+ }
+ if s != k-1 && cccB >= cccC {
+ // b[i] is blocked by greater-equal cccX below it
+ b[k] = b[i]
+ k++
+ } else {
+ l := rb.runeAt(s) // also used to compare to hangulBase
+ v := rb.runeAt(i) // also used to compare to jamoT
+ switch {
+ case jamoLBase <= l && l < jamoLEnd &&
+ jamoVBase <= v && v < jamoVEnd:
+ // 11xx plus 116x to LV
+ rb.assignRune(s, hangulBase+
+ (l-jamoLBase)*jamoVTCount+(v-jamoVBase)*jamoTCount)
+ case hangulBase <= l && l < hangulEnd &&
+ jamoTBase < v && v < jamoTEnd &&
+ ((l-hangulBase)%jamoTCount) == 0:
+ // ACxx plus 11Ax to LVT
+ rb.assignRune(s, l+v-jamoTBase)
+ default:
+ b[k] = b[i]
+ k++
+ }
+ }
+ }
+ rb.nrune = k
+}
+
+// compose recombines the runes in the buffer.
+// It should only be used to recompose a single segment, as it will not
+// handle alternations between Hangul and non-Hangul characters correctly.
+func (rb *reorderBuffer) compose() {
+ // UAX #15, section X5 , including Corrigendum #5
+ // "In any character sequence beginning with starter S, a character C is
+ // blocked from S if and only if there is some character B between S
+ // and C, and either B is a starter or it has the same or higher
+ // combining class as C."
+ bn := rb.nrune
+ if bn == 0 {
+ return
+ }
+ k := 1
+ b := rb.rune[:]
+ for s, i := 0, 1; i < bn; i++ {
+ if isJamoVT(rb.bytesAt(i)) {
+ // Redo from start in Hangul mode. Necessary to support
+ // U+320E..U+321E in NFKC mode.
+ rb.combineHangul(s, i, k)
+ return
+ }
+ ii := b[i]
+ // We can only use combineForward as a filter if we later
+ // get the info for the combined character. This is more
+ // expensive than using the filter. Using combinesBackward()
+ // is safe.
+ if ii.combinesBackward() {
+ cccB := b[k-1].ccc
+ cccC := ii.ccc
+ blocked := false // b[i] blocked by starter or greater or equal CCC?
+ if cccB == 0 {
+ s = k - 1
+ } else {
+ blocked = s != k-1 && cccB >= cccC
+ }
+ if !blocked {
+ combined := combine(rb.runeAt(s), rb.runeAt(i))
+ if combined != 0 {
+ rb.assignRune(s, combined)
+ continue
+ }
+ }
+ }
+ b[k] = b[i]
+ k++
+ }
+ rb.nrune = k
+}
diff --git a/src/pkg/exp/norm/composition_test.go b/src/pkg/exp/norm/composition_test.go
new file mode 100644
index 000000000..976aa21ed
--- /dev/null
+++ b/src/pkg/exp/norm/composition_test.go
@@ -0,0 +1,143 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import "testing"
+
+// TestCase is used for most tests.
+type TestCase struct {
+ in []rune
+ out []rune
+}
+
+type insertFunc func(rb *reorderBuffer, r rune) bool
+
+func insert(rb *reorderBuffer, r rune) bool {
+ src := inputString(string(r))
+ return rb.insert(src, 0, rb.f.info(src, 0))
+}
+
+func runTests(t *testing.T, name string, fm Form, f insertFunc, tests []TestCase) {
+ rb := reorderBuffer{}
+ rb.init(fm, nil)
+ for i, test := range tests {
+ rb.reset()
+ for j, rune := range test.in {
+ b := []byte(string(rune))
+ src := inputBytes(b)
+ if !rb.insert(src, 0, rb.f.info(src, 0)) {
+ t.Errorf("%s:%d: insert failed for rune %d", name, i, j)
+ }
+ }
+ if rb.f.composing {
+ rb.compose()
+ }
+ if rb.nrune != len(test.out) {
+ t.Errorf("%s:%d: length = %d; want %d", name, i, rb.nrune, len(test.out))
+ continue
+ }
+ for j, want := range test.out {
+ found := rune(rb.runeAt(j))
+ if found != want {
+ t.Errorf("%s:%d: runeAt(%d) = %U; want %U", name, i, j, found, want)
+ }
+ }
+ }
+}
+
+type flushFunc func(rb *reorderBuffer) []byte
+
+func testFlush(t *testing.T, name string, fn flushFunc) {
+ rb := reorderBuffer{}
+ rb.init(NFC, nil)
+ out := fn(&rb)
+ if len(out) != 0 {
+ t.Errorf("%s: wrote bytes on flush of empty buffer. (len(out) = %d)", name, len(out))
+ }
+
+ for _, r := range []rune("world!") {
+ insert(&rb, r)
+ }
+
+ out = []byte("Hello ")
+ out = rb.flush(out)
+ want := "Hello world!"
+ if string(out) != want {
+ t.Errorf(`%s: output after flush was "%s"; want "%s"`, name, string(out), want)
+ }
+ if rb.nrune != 0 {
+ t.Errorf("%s: non-null size of info buffer (rb.nrune == %d)", name, rb.nrune)
+ }
+ if rb.nbyte != 0 {
+ t.Errorf("%s: non-null size of byte buffer (rb.nbyte == %d)", name, rb.nbyte)
+ }
+}
+
+func flushF(rb *reorderBuffer) []byte {
+ out := make([]byte, 0)
+ return rb.flush(out)
+}
+
+func flushCopyF(rb *reorderBuffer) []byte {
+ out := make([]byte, maxByteBufferSize)
+ n := rb.flushCopy(out)
+ return out[:n]
+}
+
+func TestFlush(t *testing.T) {
+ testFlush(t, "flush", flushF)
+ testFlush(t, "flushCopy", flushCopyF)
+}
+
+var insertTests = []TestCase{
+ {[]rune{'a'}, []rune{'a'}},
+ {[]rune{0x300}, []rune{0x300}},
+ {[]rune{0x300, 0x316}, []rune{0x316, 0x300}}, // CCC(0x300)==230; CCC(0x316)==220
+ {[]rune{0x316, 0x300}, []rune{0x316, 0x300}},
+ {[]rune{0x41, 0x316, 0x300}, []rune{0x41, 0x316, 0x300}},
+ {[]rune{0x41, 0x300, 0x316}, []rune{0x41, 0x316, 0x300}},
+ {[]rune{0x300, 0x316, 0x41}, []rune{0x316, 0x300, 0x41}},
+ {[]rune{0x41, 0x300, 0x40, 0x316}, []rune{0x41, 0x300, 0x40, 0x316}},
+}
+
+func TestInsert(t *testing.T) {
+ runTests(t, "TestInsert", NFD, insert, insertTests)
+}
+
+var decompositionNFDTest = []TestCase{
+ {[]rune{0xC0}, []rune{0x41, 0x300}},
+ {[]rune{0xAC00}, []rune{0x1100, 0x1161}},
+ {[]rune{0x01C4}, []rune{0x01C4}},
+ {[]rune{0x320E}, []rune{0x320E}},
+ {[]rune("음ẻ과"), []rune{0x110B, 0x1173, 0x11B7, 0x65, 0x309, 0x1100, 0x116A}},
+}
+
+var decompositionNFKDTest = []TestCase{
+ {[]rune{0xC0}, []rune{0x41, 0x300}},
+ {[]rune{0xAC00}, []rune{0x1100, 0x1161}},
+ {[]rune{0x01C4}, []rune{0x44, 0x5A, 0x030C}},
+ {[]rune{0x320E}, []rune{0x28, 0x1100, 0x1161, 0x29}},
+}
+
+func TestDecomposition(t *testing.T) {
+ runTests(t, "TestDecompositionNFD", NFD, insert, decompositionNFDTest)
+ runTests(t, "TestDecompositionNFKD", NFKD, insert, decompositionNFKDTest)
+}
+
+var compositionTest = []TestCase{
+ {[]rune{0x41, 0x300}, []rune{0xC0}},
+ {[]rune{0x41, 0x316}, []rune{0x41, 0x316}},
+ {[]rune{0x41, 0x300, 0x35D}, []rune{0xC0, 0x35D}},
+ {[]rune{0x41, 0x316, 0x300}, []rune{0xC0, 0x316}},
+ // blocking starter
+ {[]rune{0x41, 0x316, 0x40, 0x300}, []rune{0x41, 0x316, 0x40, 0x300}},
+ {[]rune{0x1100, 0x1161}, []rune{0xAC00}},
+ // parenthesized Hangul, alternate between ASCII and Hangul.
+ {[]rune{0x28, 0x1100, 0x1161, 0x29}, []rune{0x28, 0xAC00, 0x29}},
+}
+
+func TestComposition(t *testing.T) {
+ runTests(t, "TestComposition", NFC, insert, compositionTest)
+}
diff --git a/src/pkg/exp/norm/example_iter_test.go b/src/pkg/exp/norm/example_iter_test.go
new file mode 100644
index 000000000..edb9fcf55
--- /dev/null
+++ b/src/pkg/exp/norm/example_iter_test.go
@@ -0,0 +1,81 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm_test
+
+import (
+ "bytes"
+ "exp/norm"
+ "fmt"
+ "unicode/utf8"
+)
+
+// EqualSimple uses a norm.Iter to compare two non-normalized
+// strings for equivalence.
+func EqualSimple(a, b string) bool {
+ var ia, ib norm.Iter
+ ia.InitString(norm.NFKD, a)
+ ib.InitString(norm.NFKD, b)
+ for !ia.Done() && !ib.Done() {
+ if !bytes.Equal(ia.Next(), ib.Next()) {
+ return false
+ }
+ }
+ return ia.Done() && ib.Done()
+}
+
+// FindPrefix finds the longest common prefix of ASCII characters
+// of a and b.
+func FindPrefix(a, b string) int {
+ i := 0
+ for ; i < len(a) && i < len(b) && a[i] < utf8.RuneSelf && a[i] == b[i]; i++ {
+ }
+ return i
+}
+
+// EqualOpt is like EqualSimple, but optimizes the special
+// case for ASCII characters.
+func EqualOpt(a, b string) bool {
+ n := FindPrefix(a, b)
+ a, b = a[n:], b[n:]
+ var ia, ib norm.Iter
+ ia.InitString(norm.NFKD, a)
+ ib.InitString(norm.NFKD, b)
+ for !ia.Done() && !ib.Done() {
+ if !bytes.Equal(ia.Next(), ib.Next()) {
+ return false
+ }
+ if n := int64(FindPrefix(a[ia.Pos():], b[ib.Pos():])); n != 0 {
+ ia.Seek(n, 1)
+ ib.Seek(n, 1)
+ }
+ }
+ return ia.Done() && ib.Done()
+}
+
+var compareTests = []struct{ a, b string }{
+ {"aaa", "aaa"},
+ {"aaa", "aab"},
+ {"a\u0300a", "\u00E0a"},
+ {"a\u0300\u0320b", "a\u0320\u0300b"},
+ {"\u1E0A\u0323", "\x44\u0323\u0307"},
+ // A character that decomposes into multiple segments
+ // spans several iterations.
+ {"\u3304", "\u30A4\u30CB\u30F3\u30AF\u3099"},
+}
+
+func ExampleIter() {
+ for i, t := range compareTests {
+ r0 := EqualSimple(t.a, t.b)
+ r1 := EqualOpt(t.a, t.b)
+ fmt.Printf("%d: %v %v\n", i, r0, r1)
+ }
+ // Output:
+ // 0: true true
+ // 1: false false
+ // 2: true true
+ // 3: true true
+ // 4: true true
+ // 5: true true
+}
diff --git a/src/pkg/exp/norm/forminfo.go b/src/pkg/exp/norm/forminfo.go
new file mode 100644
index 000000000..7f7ee72e8
--- /dev/null
+++ b/src/pkg/exp/norm/forminfo.go
@@ -0,0 +1,229 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+// This file contains Form-specific logic and wrappers for data in tables.go.
+
+// Rune info is stored in a separate trie per composing form. A composing form
+// and its corresponding decomposing form share the same trie. Each trie maps
+// a rune to a uint16. The values take two forms. For v >= 0x8000:
+// bits
+// 0..8: ccc
+// 9..12: qcInfo (see below). isYesD is always true (no decompostion).
+// 16: 1
+// For v < 0x8000, the respective rune has a decomposition and v is an index
+// into a byte array of UTF-8 decomposition sequences and additional info and
+// has the form:
+// <header> <decomp_byte>* [<tccc> [<lccc>]]
+// The header contains the number of bytes in the decomposition (excluding this
+// length byte). The two most significant bits of this length byte correspond
+// to bit 2 and 3 of qcIfo (see below). The byte sequence itself starts at v+1.
+// The byte sequence is followed by a trailing and leading CCC if the values
+// for these are not zero. The value of v determines which ccc are appended
+// to the sequences. For v < firstCCC, there are none, for v >= firstCCC,
+// the sequence is followed by a trailing ccc, and for v >= firstLeadingCC
+// there is an additional leading ccc.
+
+const (
+ qcInfoMask = 0xF // to clear all but the relevant bits in a qcInfo
+ headerLenMask = 0x3F // extract the length value from the header byte
+ headerFlagsMask = 0xC0 // extract the qcInfo bits from the header byte
+)
+
+// Properties provides access to normalization properties of a rune.
+type Properties struct {
+ pos uint8 // start position in reorderBuffer; used in composition.go
+ size uint8 // length of UTF-8 encoding of this rune
+ ccc uint8 // leading canonical combining class (ccc if not decomposition)
+ tccc uint8 // trailing canonical combining class (ccc if not decomposition)
+ flags qcInfo // quick check flags
+ index uint16
+}
+
+// functions dispatchable per form
+type lookupFunc func(b input, i int) Properties
+
+// formInfo holds Form-specific functions and tables.
+type formInfo struct {
+ form Form
+ composing, compatibility bool // form type
+ info lookupFunc
+ nextMain iterFunc
+}
+
+var formTable []*formInfo
+
+func init() {
+ formTable = make([]*formInfo, 4)
+
+ for i := range formTable {
+ f := &formInfo{}
+ formTable[i] = f
+ f.form = Form(i)
+ if Form(i) == NFKD || Form(i) == NFKC {
+ f.compatibility = true
+ f.info = lookupInfoNFKC
+ } else {
+ f.info = lookupInfoNFC
+ }
+ f.nextMain = nextDecomposed
+ if Form(i) == NFC || Form(i) == NFKC {
+ f.nextMain = nextComposed
+ f.composing = true
+ }
+ }
+}
+
+// We do not distinguish between boundaries for NFC, NFD, etc. to avoid
+// unexpected behavior for the user. For example, in NFD, there is a boundary
+// after 'a'. However, 'a' might combine with modifiers, so from the application's
+// perspective it is not a good boundary. We will therefore always use the
+// boundaries for the combining variants.
+
+// BoundaryBefore returns true if this rune starts a new segment and
+// cannot combine with any rune on the left.
+func (p Properties) BoundaryBefore() bool {
+ if p.ccc == 0 && !p.combinesBackward() {
+ return true
+ }
+ // We assume that the CCC of the first character in a decomposition
+ // is always non-zero if different from info.ccc and that we can return
+ // false at this point. This is verified by maketables.
+ return false
+}
+
+// BoundaryAfter returns true if this rune cannot combine with runes to the right
+// and always denotes the end of a segment.
+func (p Properties) BoundaryAfter() bool {
+ return p.isInert()
+}
+
+// We pack quick check data in 4 bits:
+// 0: NFD_QC Yes (0) or No (1). No also means there is a decomposition.
+// 1..2: NFC_QC Yes(00), No (10), or Maybe (11)
+// 3: Combines forward (0 == false, 1 == true)
+//
+// When all 4 bits are zero, the character is inert, meaning it is never
+// influenced by normalization.
+type qcInfo uint8
+
+func (p Properties) isYesC() bool { return p.flags&0x4 == 0 }
+func (p Properties) isYesD() bool { return p.flags&0x1 == 0 }
+
+func (p Properties) combinesForward() bool { return p.flags&0x8 != 0 }
+func (p Properties) combinesBackward() bool { return p.flags&0x2 != 0 } // == isMaybe
+func (p Properties) hasDecomposition() bool { return p.flags&0x1 != 0 } // == isNoD
+
+func (p Properties) isInert() bool {
+ return p.flags&0xf == 0 && p.ccc == 0
+}
+
+func (p Properties) multiSegment() bool {
+ return p.index >= firstMulti && p.index < endMulti
+}
+
+// Decomposition returns the decomposition for the underlying rune
+// or nil if there is none.
+func (p Properties) Decomposition() []byte {
+ if p.index == 0 {
+ return nil
+ }
+ i := p.index
+ n := decomps[i] & headerLenMask
+ i++
+ return decomps[i : i+uint16(n)]
+}
+
+// Size returns the length of UTF-8 encoding of the rune.
+func (p Properties) Size() int {
+ return int(p.size)
+}
+
+// CCC returns the canonical combining class of the underlying rune.
+func (p Properties) CCC() uint8 {
+ if p.index > firstCCCZeroExcept {
+ return 0
+ }
+ return p.ccc
+}
+
+// LeadCCC returns the CCC of the first rune in the decomposition.
+// If there is no decomposition, LeadCCC equals CCC.
+func (p Properties) LeadCCC() uint8 {
+ return p.ccc
+}
+
+// TrailCCC returns the CCC of the last rune in the decomposition.
+// If there is no decomposition, TrailCCC equals CCC.
+func (p Properties) TrailCCC() uint8 {
+ return p.tccc
+}
+
+// Recomposition
+// We use 32-bit keys instead of 64-bit for the two codepoint keys.
+// This clips off the bits of three entries, but we know this will not
+// result in a collision. In the unlikely event that changes to
+// UnicodeData.txt introduce collisions, the compiler will catch it.
+// Note that the recomposition map for NFC and NFKC are identical.
+
+// combine returns the combined rune or 0 if it doesn't exist.
+func combine(a, b rune) rune {
+ key := uint32(uint16(a))<<16 + uint32(uint16(b))
+ return recompMap[key]
+}
+
+func lookupInfoNFC(b input, i int) Properties {
+ v, sz := b.charinfoNFC(i)
+ return compInfo(v, sz)
+}
+
+func lookupInfoNFKC(b input, i int) Properties {
+ v, sz := b.charinfoNFKC(i)
+ return compInfo(v, sz)
+}
+
+// Properties returns properties for the first rune in s.
+func (f Form) Properties(s []byte) Properties {
+ if f == NFC || f == NFD {
+ return compInfo(nfcTrie.lookup(s))
+ }
+ return compInfo(nfkcTrie.lookup(s))
+}
+
+// PropertiesString returns properties for the first rune in s.
+func (f Form) PropertiesString(s string) Properties {
+ if f == NFC || f == NFD {
+ return compInfo(nfcTrie.lookupString(s))
+ }
+ return compInfo(nfkcTrie.lookupString(s))
+}
+
+// compInfo converts the information contained in v and sz
+// to a Properties. See the comment at the top of the file
+// for more information on the format.
+func compInfo(v uint16, sz int) Properties {
+ if v == 0 {
+ return Properties{size: uint8(sz)}
+ } else if v >= 0x8000 {
+ return Properties{
+ size: uint8(sz),
+ ccc: uint8(v),
+ tccc: uint8(v),
+ flags: qcInfo(v>>8) & qcInfoMask,
+ }
+ }
+ // has decomposition
+ h := decomps[v]
+ f := (qcInfo(h&headerFlagsMask) >> 4) | 0x1
+ ri := Properties{size: uint8(sz), flags: f, index: v}
+ if v >= firstCCC {
+ v += uint16(h&headerLenMask) + 1
+ ri.tccc = decomps[v]
+ if v >= firstLeadingCCC {
+ ri.ccc = decomps[v+1]
+ }
+ }
+ return ri
+}
diff --git a/src/pkg/exp/norm/input.go b/src/pkg/exp/norm/input.go
new file mode 100644
index 000000000..d0177a14a
--- /dev/null
+++ b/src/pkg/exp/norm/input.go
@@ -0,0 +1,105 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import "unicode/utf8"
+
+type input struct {
+ str string
+ bytes []byte
+}
+
+func inputBytes(str []byte) input {
+ return input{bytes: str}
+}
+
+func inputString(str string) input {
+ return input{str: str}
+}
+
+func (in *input) setBytes(str []byte) {
+ in.str = ""
+ in.bytes = str
+}
+
+func (in *input) setString(str string) {
+ in.str = str
+ in.bytes = nil
+}
+
+func (in *input) _byte(p int) byte {
+ if in.bytes == nil {
+ return in.str[p]
+ }
+ return in.bytes[p]
+}
+
+func (in *input) skipASCII(p, max int) int {
+ if in.bytes == nil {
+ for ; p < max && in.str[p] < utf8.RuneSelf; p++ {
+ }
+ } else {
+ for ; p < max && in.bytes[p] < utf8.RuneSelf; p++ {
+ }
+ }
+ return p
+}
+
+func (in *input) skipNonStarter(p int) int {
+ if in.bytes == nil {
+ for ; p < len(in.str) && !utf8.RuneStart(in.str[p]); p++ {
+ }
+ } else {
+ for ; p < len(in.bytes) && !utf8.RuneStart(in.bytes[p]); p++ {
+ }
+ }
+ return p
+}
+
+func (in *input) appendSlice(buf []byte, b, e int) []byte {
+ if in.bytes != nil {
+ return append(buf, in.bytes[b:e]...)
+ }
+ for i := b; i < e; i++ {
+ buf = append(buf, in.str[i])
+ }
+ return buf
+}
+
+func (in *input) copySlice(buf []byte, b, e int) int {
+ if in.bytes == nil {
+ return copy(buf, in.str[b:e])
+ }
+ return copy(buf, in.bytes[b:e])
+}
+
+func (in *input) charinfoNFC(p int) (uint16, int) {
+ if in.bytes == nil {
+ return nfcTrie.lookupString(in.str[p:])
+ }
+ return nfcTrie.lookup(in.bytes[p:])
+}
+
+func (in *input) charinfoNFKC(p int) (uint16, int) {
+ if in.bytes == nil {
+ return nfkcTrie.lookupString(in.str[p:])
+ }
+ return nfkcTrie.lookup(in.bytes[p:])
+}
+
+func (in *input) hangul(p int) (r rune) {
+ if in.bytes == nil {
+ if !isHangulString(in.str[p:]) {
+ return 0
+ }
+ r, _ = utf8.DecodeRuneInString(in.str[p:])
+ } else {
+ if !isHangul(in.bytes[p:]) {
+ return 0
+ }
+ r, _ = utf8.DecodeRune(in.bytes[p:])
+ }
+ return r
+}
diff --git a/src/pkg/exp/norm/iter.go b/src/pkg/exp/norm/iter.go
new file mode 100644
index 000000000..a9546247c
--- /dev/null
+++ b/src/pkg/exp/norm/iter.go
@@ -0,0 +1,401 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+ "fmt"
+ "unicode/utf8"
+)
+
+const MaxSegmentSize = maxByteBufferSize
+
+// An Iter iterates over a string or byte slice, while normalizing it
+// to a given Form.
+type Iter struct {
+ rb reorderBuffer
+ buf [maxByteBufferSize]byte
+ info Properties // first character saved from previous iteration
+ next iterFunc // implementation of next depends on form
+ asciiF iterFunc
+
+ p int // current position in input source
+ multiSeg []byte // remainder of multi-segment decomposition
+}
+
+type iterFunc func(*Iter) []byte
+
+// Init initializes i to iterate over src after normalizing it to Form f.
+func (i *Iter) Init(f Form, src []byte) {
+ i.p = 0
+ if len(src) == 0 {
+ i.setDone()
+ i.rb.nsrc = 0
+ return
+ }
+ i.multiSeg = nil
+ i.rb.init(f, src)
+ i.next = i.rb.f.nextMain
+ i.asciiF = nextASCIIBytes
+ i.info = i.rb.f.info(i.rb.src, i.p)
+}
+
+// InitString initializes i to iterate over src after normalizing it to Form f.
+func (i *Iter) InitString(f Form, src string) {
+ i.p = 0
+ if len(src) == 0 {
+ i.setDone()
+ i.rb.nsrc = 0
+ return
+ }
+ i.multiSeg = nil
+ i.rb.initString(f, src)
+ i.next = i.rb.f.nextMain
+ i.asciiF = nextASCIIString
+ i.info = i.rb.f.info(i.rb.src, i.p)
+}
+
+// Seek sets the segment to be returned by the next call to Next to start
+// at position p. It is the responsibility of the caller to set p to the
+// start of a UTF8 rune.
+func (i *Iter) Seek(offset int64, whence int) (int64, error) {
+ var abs int64
+ switch whence {
+ case 0:
+ abs = offset
+ case 1:
+ abs = int64(i.p) + offset
+ case 2:
+ abs = int64(i.rb.nsrc) + offset
+ default:
+ return 0, fmt.Errorf("norm: invalid whence")
+ }
+ if abs < 0 {
+ return 0, fmt.Errorf("norm: negative position")
+ }
+ if int(abs) >= i.rb.nsrc {
+ i.setDone()
+ return int64(i.p), nil
+ }
+ i.p = int(abs)
+ i.multiSeg = nil
+ i.next = i.rb.f.nextMain
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ return abs, nil
+}
+
+// returnSlice returns a slice of the underlying input type as a byte slice.
+// If the underlying is of type []byte, it will simply return a slice.
+// If the underlying is of type string, it will copy the slice to the buffer
+// and return that.
+func (i *Iter) returnSlice(a, b int) []byte {
+ if i.rb.src.bytes == nil {
+ return i.buf[:copy(i.buf[:], i.rb.src.str[a:b])]
+ }
+ return i.rb.src.bytes[a:b]
+}
+
+// Pos returns the byte position at which the next call to Next will commence processing.
+func (i *Iter) Pos() int {
+ return i.p
+}
+
+func (i *Iter) setDone() {
+ i.next = nextDone
+ i.p = i.rb.nsrc
+}
+
+// Done returns true if there is no more input to process.
+func (i *Iter) Done() bool {
+ return i.p >= i.rb.nsrc
+}
+
+// Next returns f(i.input[i.Pos():n]), where n is a boundary of i.input.
+// For any input a and b for which f(a) == f(b), subsequent calls
+// to Next will return the same segments.
+// Modifying runes are grouped together with the preceding starter, if such a starter exists.
+// Although not guaranteed, n will typically be the smallest possible n.
+func (i *Iter) Next() []byte {
+ return i.next(i)
+}
+
+func nextASCIIBytes(i *Iter) []byte {
+ p := i.p + 1
+ if p >= i.rb.nsrc {
+ i.setDone()
+ return i.rb.src.bytes[i.p:p]
+ }
+ if i.rb.src.bytes[p] < utf8.RuneSelf {
+ p0 := i.p
+ i.p = p
+ return i.rb.src.bytes[p0:p]
+ }
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ i.next = i.rb.f.nextMain
+ return i.next(i)
+}
+
+func nextASCIIString(i *Iter) []byte {
+ p := i.p + 1
+ if p >= i.rb.nsrc {
+ i.buf[0] = i.rb.src.str[i.p]
+ i.setDone()
+ return i.buf[:1]
+ }
+ if i.rb.src.str[p] < utf8.RuneSelf {
+ i.buf[0] = i.rb.src.str[i.p]
+ i.p = p
+ return i.buf[:1]
+ }
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ i.next = i.rb.f.nextMain
+ return i.next(i)
+}
+
+func nextHangul(i *Iter) []byte {
+ if r := i.rb.src.hangul(i.p); r != 0 {
+ i.p += hangulUTF8Size
+ if i.p >= i.rb.nsrc {
+ i.setDone()
+ }
+ return i.buf[:decomposeHangul(i.buf[:], r)]
+ }
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ i.next = i.rb.f.nextMain
+ return i.next(i)
+}
+
+func nextDone(i *Iter) []byte {
+ return nil
+}
+
+// nextMulti is used for iterating over multi-segment decompositions
+// for decomposing normal forms.
+func nextMulti(i *Iter) []byte {
+ j := 0
+ d := i.multiSeg
+ // skip first rune
+ for j = 1; j < len(d) && !utf8.RuneStart(d[j]); j++ {
+ }
+ for j < len(d) {
+ info := i.rb.f.info(input{bytes: d}, j)
+ if info.ccc == 0 {
+ i.multiSeg = d[j:]
+ return d[:j]
+ }
+ j += int(info.size)
+ }
+ // treat last segment as normal decomposition
+ i.next = i.rb.f.nextMain
+ return i.next(i)
+}
+
+// nextMultiNorm is used for iterating over multi-segment decompositions
+// for composing normal forms.
+func nextMultiNorm(i *Iter) []byte {
+ j := 0
+ d := i.multiSeg
+ // skip first rune
+ for j = 1; j < len(d) && !utf8.RuneStart(d[j]); j++ {
+ }
+ for j < len(d) {
+ info := i.rb.f.info(input{bytes: d}, j)
+ if info.ccc == 0 {
+ i.multiSeg = d[j:]
+ return d[:j]
+ }
+ j += int(info.size)
+ }
+ i.multiSeg = nil
+ i.next = nextComposed
+ i.p++ // restore old valud of i.p. See nextComposed.
+ if i.p >= i.rb.nsrc {
+ i.setDone()
+ }
+ return d
+}
+
+// nextDecomposed is the implementation of Next for forms NFD and NFKD.
+func nextDecomposed(i *Iter) (next []byte) {
+ startp, outp := i.p, 0
+ inCopyStart, outCopyStart := i.p, 0
+ for {
+ if sz := int(i.info.size); sz <= 1 {
+ p := i.p
+ i.p++ // ASCII or illegal byte. Either way, advance by 1.
+ if i.p >= i.rb.nsrc {
+ i.setDone()
+ return i.returnSlice(p, i.p)
+ } else if i.rb.src._byte(i.p) < utf8.RuneSelf {
+ i.next = i.asciiF
+ return i.returnSlice(p, i.p)
+ }
+ outp++
+ } else if d := i.info.Decomposition(); d != nil {
+ // Note: If leading CCC != 0, then len(d) == 2 and last is also non-zero.
+ // Case 1: there is a leftover to copy. In this case the decomposition
+ // must begin with a modifier and should always be appended.
+ // Case 2: no leftover. Simply return d if followed by a ccc == 0 value.
+ p := outp + len(d)
+ if outp > 0 {
+ i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+ if p > len(i.buf) {
+ return i.buf[:outp]
+ }
+ } else if i.info.multiSegment() {
+ // outp must be 0 as multi-segment decompositions always
+ // start a new segment.
+ if i.multiSeg == nil {
+ i.multiSeg = d
+ i.next = nextMulti
+ return nextMulti(i)
+ }
+ // We are in the last segment. Treat as normal decomposition.
+ d = i.multiSeg
+ i.multiSeg = nil
+ p = len(d)
+ }
+ prevCC := i.info.tccc
+ if i.p += sz; i.p >= i.rb.nsrc {
+ i.setDone()
+ i.info = Properties{} // Force BoundaryBefore to succeed.
+ } else {
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ }
+ if i.info.BoundaryBefore() {
+ if outp > 0 {
+ copy(i.buf[outp:], d)
+ return i.buf[:p]
+ }
+ return d
+ }
+ copy(i.buf[outp:], d)
+ outp = p
+ inCopyStart, outCopyStart = i.p, outp
+ if i.info.ccc < prevCC {
+ goto doNorm
+ }
+ continue
+ } else if r := i.rb.src.hangul(i.p); r != 0 {
+ i.next = nextHangul
+ i.p += hangulUTF8Size
+ if i.p >= i.rb.nsrc {
+ i.setDone()
+ }
+ return i.buf[:decomposeHangul(i.buf[:], r)]
+ } else {
+ p := outp + sz
+ if p > len(i.buf) {
+ break
+ }
+ outp = p
+ i.p += sz
+ }
+ if i.p >= i.rb.nsrc {
+ i.setDone()
+ break
+ }
+ prevCC := i.info.tccc
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ if i.info.BoundaryBefore() {
+ break
+ } else if i.info.ccc < prevCC {
+ goto doNorm
+ }
+ }
+ if outCopyStart == 0 {
+ return i.returnSlice(inCopyStart, i.p)
+ } else if inCopyStart < i.p {
+ i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+ }
+ return i.buf[:outp]
+doNorm:
+ // Insert what we have decomposed so far in the reorderBuffer.
+ // As we will only reorder, there will always be enough room.
+ i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+ if !i.rb.insertDecomposed(i.buf[0:outp]) {
+ // Start over to prevent decompositions from crossing segment boundaries.
+ // This is a rare occurrence.
+ i.p = startp
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ }
+ for {
+ if !i.rb.insert(i.rb.src, i.p, i.info) {
+ break
+ }
+ if i.p += int(i.info.size); i.p >= i.rb.nsrc {
+ i.setDone()
+ break
+ }
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ if i.info.ccc == 0 {
+ break
+ }
+ }
+ // new segment or too many combining characters: exit normalization
+ return i.buf[:i.rb.flushCopy(i.buf[:])]
+}
+
+// nextComposed is the implementation of Next for forms NFC and NFKC.
+func nextComposed(i *Iter) []byte {
+ outp, startp := 0, i.p
+ var prevCC uint8
+ for {
+ if !i.info.isYesC() {
+ goto doNorm
+ }
+ if cc := i.info.ccc; cc == 0 && outp > 0 {
+ break
+ } else if cc < prevCC {
+ goto doNorm
+ }
+ prevCC = i.info.tccc
+ sz := int(i.info.size)
+ if sz == 0 {
+ sz = 1 // illegal rune: copy byte-by-byte
+ }
+ p := outp + sz
+ if p > len(i.buf) {
+ break
+ }
+ outp = p
+ i.p += sz
+ if i.p >= i.rb.nsrc {
+ i.setDone()
+ break
+ } else if i.rb.src._byte(i.p) < utf8.RuneSelf {
+ i.next = i.asciiF
+ break
+ }
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ }
+ return i.returnSlice(startp, i.p)
+doNorm:
+ multi := false
+ i.p = startp
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ for {
+ if !i.rb.insert(i.rb.src, i.p, i.info) {
+ break
+ }
+ multi = multi || i.info.multiSegment()
+ if i.p += int(i.info.size); i.p >= i.rb.nsrc {
+ i.setDone()
+ break
+ }
+ i.info = i.rb.f.info(i.rb.src, i.p)
+ if i.info.BoundaryBefore() {
+ break
+ }
+ }
+ i.rb.compose()
+ seg := i.buf[:i.rb.flushCopy(i.buf[:])]
+ if multi {
+ i.p-- // fake not being done yet
+ i.multiSeg = seg
+ i.next = nextMultiNorm
+ return nextMultiNorm(i)
+ }
+ return seg
+}
diff --git a/src/pkg/exp/norm/iter_test.go b/src/pkg/exp/norm/iter_test.go
new file mode 100644
index 000000000..826119362
--- /dev/null
+++ b/src/pkg/exp/norm/iter_test.go
@@ -0,0 +1,188 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+ "strings"
+ "testing"
+)
+
+func doIterNorm(f Form, s string) []byte {
+ acc := []byte{}
+ i := Iter{}
+ i.InitString(f, s)
+ for !i.Done() {
+ acc = append(acc, i.Next()...)
+ }
+ return acc
+}
+
+func runIterTests(t *testing.T, name string, f Form, tests []AppendTest, norm bool) {
+ for i, test := range tests {
+ in := test.left + test.right
+ gold := test.out
+ if norm {
+ gold = string(f.AppendString(nil, test.out))
+ }
+ out := string(doIterNorm(f, in))
+ if len(out) != len(gold) {
+ const msg = "%s:%d: length is %d; want %d"
+ t.Errorf(msg, name, i, len(out), len(gold))
+ }
+ if out != gold {
+ // Find first rune that differs and show context.
+ ir := []rune(out)
+ ig := []rune(gold)
+ t.Errorf("\n%X != \n%X", ir, ig)
+ for j := 0; j < len(ir) && j < len(ig); j++ {
+ if ir[j] == ig[j] {
+ continue
+ }
+ if j -= 3; j < 0 {
+ j = 0
+ }
+ for e := j + 7; j < e && j < len(ir) && j < len(ig); j++ {
+ const msg = "%s:%d: runeAt(%d) = %U; want %U"
+ t.Errorf(msg, name, i, j, ir[j], ig[j])
+ }
+ break
+ }
+ }
+ }
+}
+
+func rep(r rune, n int) string {
+ return strings.Repeat(string(r), n)
+}
+
+const segSize = maxByteBufferSize
+
+var iterTests = []AppendTest{
+ {"", ascii, ascii},
+ {"", txt_all, txt_all},
+ {"", "a" + rep(0x0300, segSize/2), "a" + rep(0x0300, segSize/2)},
+}
+
+var iterTestsD = []AppendTest{
+ { // segment overflow on unchanged character
+ "",
+ "a" + rep(0x0300, segSize/2) + "\u0316",
+ "a" + rep(0x0300, segSize/2-1) + "\u0316\u0300",
+ },
+ { // segment overflow on unchanged character + start value
+ "",
+ "a" + rep(0x0300, segSize/2+maxCombiningChars+4) + "\u0316",
+ "a" + rep(0x0300, segSize/2+maxCombiningChars) + "\u0316" + rep(0x300, 4),
+ },
+ { // segment overflow on decomposition
+ "",
+ "a" + rep(0x0300, segSize/2-1) + "\u0340",
+ "a" + rep(0x0300, segSize/2),
+ },
+ { // segment overflow on decomposition + start value
+ "",
+ "a" + rep(0x0300, segSize/2-1) + "\u0340" + rep(0x300, maxCombiningChars+4) + "\u0320",
+ "a" + rep(0x0300, segSize/2-1) + rep(0x300, maxCombiningChars+1) + "\u0320" + rep(0x300, 4),
+ },
+ { // start value after ASCII overflow
+ "",
+ rep('a', segSize) + rep(0x300, maxCombiningChars+2) + "\u0320",
+ rep('a', segSize) + rep(0x300, maxCombiningChars) + "\u0320\u0300\u0300",
+ },
+ { // start value after Hangul overflow
+ "",
+ rep(0xAC00, segSize/6) + rep(0x300, maxCombiningChars+2) + "\u0320",
+ strings.Repeat("\u1100\u1161", segSize/6) + rep(0x300, maxCombiningChars+1) + "\u0320" + rep(0x300, 1),
+ },
+ { // start value after cc=0
+ "",
+ "您您" + rep(0x300, maxCombiningChars+4) + "\u0320",
+ "您您" + rep(0x300, maxCombiningChars) + "\u0320" + rep(0x300, 4),
+ },
+ { // start value after normalization
+ "",
+ "\u0300\u0320a" + rep(0x300, maxCombiningChars+4) + "\u0320",
+ "\u0320\u0300a" + rep(0x300, maxCombiningChars) + "\u0320" + rep(0x300, 4),
+ },
+}
+
+var iterTestsC = []AppendTest{
+ { // ordering of non-composing combining characters
+ "",
+ "\u0305\u0316",
+ "\u0316\u0305",
+ },
+ { // segment overflow
+ "",
+ "a" + rep(0x0305, segSize/2+4) + "\u0316",
+ "a" + rep(0x0305, segSize/2-1) + "\u0316" + rep(0x305, 5),
+ },
+}
+
+func TestIterNextD(t *testing.T) {
+ runIterTests(t, "IterNextD1", NFKD, appendTests, true)
+ runIterTests(t, "IterNextD2", NFKD, iterTests, true)
+ runIterTests(t, "IterNextD3", NFKD, iterTestsD, false)
+}
+
+func TestIterNextC(t *testing.T) {
+ runIterTests(t, "IterNextC1", NFKC, appendTests, true)
+ runIterTests(t, "IterNextC2", NFKC, iterTests, true)
+ runIterTests(t, "IterNextC3", NFKC, iterTestsC, false)
+}
+
+type SegmentTest struct {
+ in string
+ out []string
+}
+
+var segmentTests = []SegmentTest{
+ {"\u1E0A\u0323a", []string{"\x44\u0323\u0307", "a", ""}},
+ {rep('a', segSize), append(strings.Split(rep('a', segSize), ""), "")},
+ {rep('a', segSize+2), append(strings.Split(rep('a', segSize+2), ""), "")},
+ {rep('a', segSize) + "\u0300aa",
+ append(strings.Split(rep('a', segSize-1), ""), "a\u0300", "a", "a", "")},
+}
+
+var segmentTestsK = []SegmentTest{
+ {"\u3332", []string{"\u30D5", "\u30A1", "\u30E9", "\u30C3", "\u30C8\u3099", ""}},
+ // last segment of multi-segment decomposition needs normalization
+ {"\u3332\u093C", []string{"\u30D5", "\u30A1", "\u30E9", "\u30C3", "\u30C8\u093C\u3099", ""}},
+ // Hangul and Jamo are grouped togeter.
+ {"\uAC00", []string{"\u1100\u1161", ""}},
+ {"\uAC01", []string{"\u1100\u1161\u11A8", ""}},
+ {"\u1100\u1161", []string{"\u1100\u1161", ""}},
+}
+
+// Note that, by design, segmentation is equal for composing and decomposing forms.
+func TestIterSegmentation(t *testing.T) {
+ segmentTest(t, "SegmentTestD", NFD, segmentTests)
+ segmentTest(t, "SegmentTestC", NFC, segmentTests)
+ segmentTest(t, "SegmentTestD", NFKD, segmentTestsK)
+ segmentTest(t, "SegmentTestC", NFKC, segmentTestsK)
+}
+
+func segmentTest(t *testing.T, name string, f Form, tests []SegmentTest) {
+ iter := Iter{}
+ for i, tt := range tests {
+ iter.InitString(f, tt.in)
+ for j, seg := range tt.out {
+ if seg == "" {
+ if !iter.Done() {
+ res := string(iter.Next())
+ t.Errorf(`%s:%d:%d: expected Done()==true, found segment "%s"`, name, i, j, res)
+ }
+ continue
+ }
+ if iter.Done() {
+ t.Errorf("%s:%d:%d: Done()==true, want false", name, i, j)
+ }
+ seg = f.String(seg)
+ if res := string(iter.Next()); res != seg {
+ t.Errorf(`%s:%d:%d" segment was "%s" (%d); want "%s" (%d) %X %X`, name, i, j, res, len(res), seg, len(seg), []rune(res), []rune(seg))
+ }
+ }
+ }
+}
diff --git a/src/pkg/exp/norm/maketables.go b/src/pkg/exp/norm/maketables.go
new file mode 100644
index 000000000..50c0c310a
--- /dev/null
+++ b/src/pkg/exp/norm/maketables.go
@@ -0,0 +1,923 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// Normalization table generator.
+// Data read from the web.
+// See forminfo.go for a description of the trie values associated with each rune.
+
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "flag"
+ "fmt"
+ "io"
+ "log"
+ "net/http"
+ "os"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "unicode"
+)
+
+func main() {
+ flag.Parse()
+ loadUnicodeData()
+ loadCompositionExclusions()
+ completeCharFields(FCanonical)
+ completeCharFields(FCompatibility)
+ verifyComputed()
+ printChars()
+ makeTables()
+ testDerived()
+}
+
+var url = flag.String("url",
+ "http://www.unicode.org/Public/"+unicode.Version+"/ucd/",
+ "URL of Unicode database directory")
+var tablelist = flag.String("tables",
+ "all",
+ "comma-separated list of which tables to generate; "+
+ "can be 'decomp', 'recomp', 'info' and 'all'")
+var test = flag.Bool("test",
+ false,
+ "test existing tables; can be used to compare web data with package data")
+var verbose = flag.Bool("verbose",
+ false,
+ "write data to stdout as it is parsed")
+var localFiles = flag.Bool("local",
+ false,
+ "data files have been copied to the current directory; for debugging only")
+
+var logger = log.New(os.Stderr, "", log.Lshortfile)
+
+// UnicodeData.txt has form:
+// 0037;DIGIT SEVEN;Nd;0;EN;;7;7;7;N;;;;;
+// 007A;LATIN SMALL LETTER Z;Ll;0;L;;;;;N;;;005A;;005A
+// See http://unicode.org/reports/tr44/ for full explanation
+// The fields:
+const (
+ FCodePoint = iota
+ FName
+ FGeneralCategory
+ FCanonicalCombiningClass
+ FBidiClass
+ FDecompMapping
+ FDecimalValue
+ FDigitValue
+ FNumericValue
+ FBidiMirrored
+ FUnicode1Name
+ FISOComment
+ FSimpleUppercaseMapping
+ FSimpleLowercaseMapping
+ FSimpleTitlecaseMapping
+ NumField
+
+ MaxChar = 0x10FFFF // anything above this shouldn't exist
+)
+
+// Quick Check properties of runes allow us to quickly
+// determine whether a rune may occur in a normal form.
+// For a given normal form, a rune may be guaranteed to occur
+// verbatim (QC=Yes), may or may not combine with another
+// rune (QC=Maybe), or may not occur (QC=No).
+type QCResult int
+
+const (
+ QCUnknown QCResult = iota
+ QCYes
+ QCNo
+ QCMaybe
+)
+
+func (r QCResult) String() string {
+ switch r {
+ case QCYes:
+ return "Yes"
+ case QCNo:
+ return "No"
+ case QCMaybe:
+ return "Maybe"
+ }
+ return "***UNKNOWN***"
+}
+
+const (
+ FCanonical = iota // NFC or NFD
+ FCompatibility // NFKC or NFKD
+ FNumberOfFormTypes
+)
+
+const (
+ MComposed = iota // NFC or NFKC
+ MDecomposed // NFD or NFKD
+ MNumberOfModes
+)
+
+// This contains only the properties we're interested in.
+type Char struct {
+ name string
+ codePoint rune // if zero, this index is not a valid code point.
+ ccc uint8 // canonical combining class
+ excludeInComp bool // from CompositionExclusions.txt
+ compatDecomp bool // it has a compatibility expansion
+
+ forms [FNumberOfFormTypes]FormInfo // For FCanonical and FCompatibility
+
+ state State
+}
+
+var chars = make([]Char, MaxChar+1)
+
+func (c Char) String() string {
+ buf := new(bytes.Buffer)
+
+ fmt.Fprintf(buf, "%U [%s]:\n", c.codePoint, c.name)
+ fmt.Fprintf(buf, " ccc: %v\n", c.ccc)
+ fmt.Fprintf(buf, " excludeInComp: %v\n", c.excludeInComp)
+ fmt.Fprintf(buf, " compatDecomp: %v\n", c.compatDecomp)
+ fmt.Fprintf(buf, " state: %v\n", c.state)
+ fmt.Fprintf(buf, " NFC:\n")
+ fmt.Fprint(buf, c.forms[FCanonical])
+ fmt.Fprintf(buf, " NFKC:\n")
+ fmt.Fprint(buf, c.forms[FCompatibility])
+
+ return buf.String()
+}
+
+// In UnicodeData.txt, some ranges are marked like this:
+// 3400;<CJK Ideograph Extension A, First>;Lo;0;L;;;;;N;;;;;
+// 4DB5;<CJK Ideograph Extension A, Last>;Lo;0;L;;;;;N;;;;;
+// parseCharacter keeps a state variable indicating the weirdness.
+type State int
+
+const (
+ SNormal State = iota // known to be zero for the type
+ SFirst
+ SLast
+ SMissing
+)
+
+var lastChar = rune('\u0000')
+
+func (c Char) isValid() bool {
+ return c.codePoint != 0 && c.state != SMissing
+}
+
+type FormInfo struct {
+ quickCheck [MNumberOfModes]QCResult // index: MComposed or MDecomposed
+ verified [MNumberOfModes]bool // index: MComposed or MDecomposed
+
+ combinesForward bool // May combine with rune on the right
+ combinesBackward bool // May combine with rune on the left
+ isOneWay bool // Never appears in result
+ inDecomp bool // Some decompositions result in this char.
+ decomp Decomposition
+ expandedDecomp Decomposition
+}
+
+func (f FormInfo) String() string {
+ buf := bytes.NewBuffer(make([]byte, 0))
+
+ fmt.Fprintf(buf, " quickCheck[C]: %v\n", f.quickCheck[MComposed])
+ fmt.Fprintf(buf, " quickCheck[D]: %v\n", f.quickCheck[MDecomposed])
+ fmt.Fprintf(buf, " cmbForward: %v\n", f.combinesForward)
+ fmt.Fprintf(buf, " cmbBackward: %v\n", f.combinesBackward)
+ fmt.Fprintf(buf, " isOneWay: %v\n", f.isOneWay)
+ fmt.Fprintf(buf, " inDecomp: %v\n", f.inDecomp)
+ fmt.Fprintf(buf, " decomposition: %X\n", f.decomp)
+ fmt.Fprintf(buf, " expandedDecomp: %X\n", f.expandedDecomp)
+
+ return buf.String()
+}
+
+type Decomposition []rune
+
+func openReader(file string) (input io.ReadCloser) {
+ if *localFiles {
+ f, err := os.Open(file)
+ if err != nil {
+ logger.Fatal(err)
+ }
+ input = f
+ } else {
+ path := *url + file
+ resp, err := http.Get(path)
+ if err != nil {
+ logger.Fatal(err)
+ }
+ if resp.StatusCode != 200 {
+ logger.Fatal("bad GET status for "+file, resp.Status)
+ }
+ input = resp.Body
+ }
+ return
+}
+
+func parseDecomposition(s string, skipfirst bool) (a []rune, e error) {
+ decomp := strings.Split(s, " ")
+ if len(decomp) > 0 && skipfirst {
+ decomp = decomp[1:]
+ }
+ for _, d := range decomp {
+ point, err := strconv.ParseUint(d, 16, 64)
+ if err != nil {
+ return a, err
+ }
+ a = append(a, rune(point))
+ }
+ return a, nil
+}
+
+func parseCharacter(line string) {
+ field := strings.Split(line, ";")
+ if len(field) != NumField {
+ logger.Fatalf("%5s: %d fields (expected %d)\n", line, len(field), NumField)
+ }
+ x, err := strconv.ParseUint(field[FCodePoint], 16, 64)
+ point := int(x)
+ if err != nil {
+ logger.Fatalf("%.5s...: %s", line, err)
+ }
+ if point == 0 {
+ return // not interesting and we use 0 as unset
+ }
+ if point > MaxChar {
+ logger.Fatalf("%5s: Rune %X > MaxChar (%X)", line, point, MaxChar)
+ return
+ }
+ state := SNormal
+ switch {
+ case strings.Index(field[FName], ", First>") > 0:
+ state = SFirst
+ case strings.Index(field[FName], ", Last>") > 0:
+ state = SLast
+ }
+ firstChar := lastChar + 1
+ lastChar = rune(point)
+ if state != SLast {
+ firstChar = lastChar
+ }
+ x, err = strconv.ParseUint(field[FCanonicalCombiningClass], 10, 64)
+ if err != nil {
+ logger.Fatalf("%U: bad ccc field: %s", int(x), err)
+ }
+ ccc := uint8(x)
+ decmap := field[FDecompMapping]
+ exp, e := parseDecomposition(decmap, false)
+ isCompat := false
+ if e != nil {
+ if len(decmap) > 0 {
+ exp, e = parseDecomposition(decmap, true)
+ if e != nil {
+ logger.Fatalf(`%U: bad decomp |%v|: "%s"`, int(x), decmap, e)
+ }
+ isCompat = true
+ }
+ }
+ for i := firstChar; i <= lastChar; i++ {
+ char := &chars[i]
+ char.name = field[FName]
+ char.codePoint = i
+ char.forms[FCompatibility].decomp = exp
+ if !isCompat {
+ char.forms[FCanonical].decomp = exp
+ } else {
+ char.compatDecomp = true
+ }
+ if len(decmap) > 0 {
+ char.forms[FCompatibility].decomp = exp
+ }
+ char.ccc = ccc
+ char.state = SMissing
+ if i == lastChar {
+ char.state = state
+ }
+ }
+ return
+}
+
+func loadUnicodeData() {
+ f := openReader("UnicodeData.txt")
+ defer f.Close()
+ scanner := bufio.NewScanner(f)
+ for scanner.Scan() {
+ parseCharacter(scanner.Text())
+ }
+ if scanner.Err() != nil {
+ logger.Fatal(scanner.Err())
+ }
+}
+
+var singlePointRe = regexp.MustCompile(`^([0-9A-F]+) *$`)
+
+// CompositionExclusions.txt has form:
+// 0958 # ...
+// See http://unicode.org/reports/tr44/ for full explanation
+func parseExclusion(line string) int {
+ comment := strings.Index(line, "#")
+ if comment >= 0 {
+ line = line[0:comment]
+ }
+ if len(line) == 0 {
+ return 0
+ }
+ matches := singlePointRe.FindStringSubmatch(line)
+ if len(matches) != 2 {
+ logger.Fatalf("%s: %d matches (expected 1)\n", line, len(matches))
+ }
+ point, err := strconv.ParseUint(matches[1], 16, 64)
+ if err != nil {
+ logger.Fatalf("%.5s...: %s", line, err)
+ }
+ return int(point)
+}
+
+func loadCompositionExclusions() {
+ f := openReader("CompositionExclusions.txt")
+ defer f.Close()
+ scanner := bufio.NewScanner(f)
+ for scanner.Scan() {
+ point := parseExclusion(scanner.Text())
+ if point == 0 {
+ continue
+ }
+ c := &chars[point]
+ if c.excludeInComp {
+ logger.Fatalf("%U: Duplicate entry in exclusions.", c.codePoint)
+ }
+ c.excludeInComp = true
+ }
+ if scanner.Err() != nil {
+ log.Fatal(scanner.Err())
+ }
+}
+
+// hasCompatDecomp returns true if any of the recursive
+// decompositions contains a compatibility expansion.
+// In this case, the character may not occur in NFK*.
+func hasCompatDecomp(r rune) bool {
+ c := &chars[r]
+ if c.compatDecomp {
+ return true
+ }
+ for _, d := range c.forms[FCompatibility].decomp {
+ if hasCompatDecomp(d) {
+ return true
+ }
+ }
+ return false
+}
+
+// Hangul related constants.
+const (
+ HangulBase = 0xAC00
+ HangulEnd = 0xD7A4 // hangulBase + Jamo combinations (19 * 21 * 28)
+
+ JamoLBase = 0x1100
+ JamoLEnd = 0x1113
+ JamoVBase = 0x1161
+ JamoVEnd = 0x1176
+ JamoTBase = 0x11A8
+ JamoTEnd = 0x11C3
+)
+
+func isHangul(r rune) bool {
+ return HangulBase <= r && r < HangulEnd
+}
+
+func ccc(r rune) uint8 {
+ return chars[r].ccc
+}
+
+// Insert a rune in a buffer, ordered by Canonical Combining Class.
+func insertOrdered(b Decomposition, r rune) Decomposition {
+ n := len(b)
+ b = append(b, 0)
+ cc := ccc(r)
+ if cc > 0 {
+ // Use bubble sort.
+ for ; n > 0; n-- {
+ if ccc(b[n-1]) <= cc {
+ break
+ }
+ b[n] = b[n-1]
+ }
+ }
+ b[n] = r
+ return b
+}
+
+// Recursively decompose.
+func decomposeRecursive(form int, r rune, d Decomposition) Decomposition {
+ if isHangul(r) {
+ return d
+ }
+ dcomp := chars[r].forms[form].decomp
+ if len(dcomp) == 0 {
+ return insertOrdered(d, r)
+ }
+ for _, c := range dcomp {
+ d = decomposeRecursive(form, c, d)
+ }
+ return d
+}
+
+func completeCharFields(form int) {
+ // Phase 0: pre-expand decomposition.
+ for i := range chars {
+ f := &chars[i].forms[form]
+ if len(f.decomp) == 0 {
+ continue
+ }
+ exp := make(Decomposition, 0)
+ for _, c := range f.decomp {
+ exp = decomposeRecursive(form, c, exp)
+ }
+ f.expandedDecomp = exp
+ }
+
+ // Phase 1: composition exclusion, mark decomposition.
+ for i := range chars {
+ c := &chars[i]
+ f := &c.forms[form]
+
+ // Marks script-specific exclusions and version restricted.
+ f.isOneWay = c.excludeInComp
+
+ // Singletons
+ f.isOneWay = f.isOneWay || len(f.decomp) == 1
+
+ // Non-starter decompositions
+ if len(f.decomp) > 1 {
+ chk := c.ccc != 0 || chars[f.decomp[0]].ccc != 0
+ f.isOneWay = f.isOneWay || chk
+ }
+
+ // Runes that decompose into more than two runes.
+ f.isOneWay = f.isOneWay || len(f.decomp) > 2
+
+ if form == FCompatibility {
+ f.isOneWay = f.isOneWay || hasCompatDecomp(c.codePoint)
+ }
+
+ for _, r := range f.decomp {
+ chars[r].forms[form].inDecomp = true
+ }
+ }
+
+ // Phase 2: forward and backward combining.
+ for i := range chars {
+ c := &chars[i]
+ f := &c.forms[form]
+
+ if !f.isOneWay && len(f.decomp) == 2 {
+ f0 := &chars[f.decomp[0]].forms[form]
+ f1 := &chars[f.decomp[1]].forms[form]
+ if !f0.isOneWay {
+ f0.combinesForward = true
+ }
+ if !f1.isOneWay {
+ f1.combinesBackward = true
+ }
+ }
+ }
+
+ // Phase 3: quick check values.
+ for i := range chars {
+ c := &chars[i]
+ f := &c.forms[form]
+
+ switch {
+ case len(f.decomp) > 0:
+ f.quickCheck[MDecomposed] = QCNo
+ case isHangul(rune(i)):
+ f.quickCheck[MDecomposed] = QCNo
+ default:
+ f.quickCheck[MDecomposed] = QCYes
+ }
+ switch {
+ case f.isOneWay:
+ f.quickCheck[MComposed] = QCNo
+ case (i & 0xffff00) == JamoLBase:
+ f.quickCheck[MComposed] = QCYes
+ if JamoLBase <= i && i < JamoLEnd {
+ f.combinesForward = true
+ }
+ if JamoVBase <= i && i < JamoVEnd {
+ f.quickCheck[MComposed] = QCMaybe
+ f.combinesBackward = true
+ f.combinesForward = true
+ }
+ if JamoTBase <= i && i < JamoTEnd {
+ f.quickCheck[MComposed] = QCMaybe
+ f.combinesBackward = true
+ }
+ case !f.combinesBackward:
+ f.quickCheck[MComposed] = QCYes
+ default:
+ f.quickCheck[MComposed] = QCMaybe
+ }
+ }
+}
+
+func printBytes(b []byte, name string) {
+ fmt.Printf("// %s: %d bytes\n", name, len(b))
+ fmt.Printf("var %s = [...]byte {", name)
+ for i, c := range b {
+ switch {
+ case i%64 == 0:
+ fmt.Printf("\n// Bytes %x - %x\n", i, i+63)
+ case i%8 == 0:
+ fmt.Printf("\n")
+ }
+ fmt.Printf("0x%.2X, ", c)
+ }
+ fmt.Print("\n}\n\n")
+}
+
+// See forminfo.go for format.
+func makeEntry(f *FormInfo) uint16 {
+ e := uint16(0)
+ if f.combinesForward {
+ e |= 0x8
+ }
+ if f.quickCheck[MDecomposed] == QCNo {
+ e |= 0x1
+ }
+ switch f.quickCheck[MComposed] {
+ case QCYes:
+ case QCNo:
+ e |= 0x4
+ case QCMaybe:
+ e |= 0x6
+ default:
+ log.Fatalf("Illegal quickcheck value %v.", f.quickCheck[MComposed])
+ }
+ return e
+}
+
+// decompSet keeps track of unique decompositions, grouped by whether
+// the decomposition is followed by a trailing and/or leading CCC.
+type decompSet [6]map[string]bool
+
+const (
+ normalDecomp = iota
+ firstMulti
+ firstCCC
+ endMulti
+ firstLeadingCCC
+ firstCCCZeroExcept
+ lastDecomp
+)
+
+var cname = []string{"firstMulti", "firstCCC", "endMulti", "firstLeadingCCC", "firstCCCZeroExcept", "lastDecomp"}
+
+func makeDecompSet() decompSet {
+ m := decompSet{}
+ for i := range m {
+ m[i] = make(map[string]bool)
+ }
+ return m
+}
+func (m *decompSet) insert(key int, s string) {
+ m[key][s] = true
+}
+
+func printCharInfoTables() int {
+ mkstr := func(r rune, f *FormInfo) (int, string) {
+ d := f.expandedDecomp
+ s := string([]rune(d))
+ if max := 1 << 6; len(s) >= max {
+ const msg = "%U: too many bytes in decomposition: %d >= %d"
+ logger.Fatalf(msg, r, len(s), max)
+ }
+ head := uint8(len(s))
+ if f.quickCheck[MComposed] != QCYes {
+ head |= 0x40
+ }
+ if f.combinesForward {
+ head |= 0x80
+ }
+ s = string([]byte{head}) + s
+
+ lccc := ccc(d[0])
+ tccc := ccc(d[len(d)-1])
+ cc := ccc(r)
+ if cc != 0 && lccc == 0 && tccc == 0 {
+ logger.Fatalf("%U: trailing and leading ccc are 0 for non-zero ccc %d", r, cc)
+ }
+ if tccc < lccc && lccc != 0 {
+ const msg = "%U: lccc (%d) must be <= tcc (%d)"
+ logger.Fatalf(msg, r, lccc, tccc)
+ }
+ index := normalDecomp
+ if tccc > 0 || lccc > 0 {
+ s += string([]byte{tccc})
+ index = endMulti
+ for _, r := range d[1:] {
+ if ccc(r) == 0 {
+ index = firstCCC
+ }
+ }
+ if lccc > 0 {
+ s += string([]byte{lccc})
+ if index == firstCCC {
+ logger.Fatalf("%U: multi-segment decomposition not supported for decompositions with leading CCC != 0", r)
+ }
+ index = firstLeadingCCC
+ }
+ if cc != lccc {
+ if cc != 0 {
+ logger.Fatalf("%U: for lccc != ccc, expected ccc to be 0; was %d", r, cc)
+ }
+ index = firstCCCZeroExcept
+ }
+ } else if len(d) > 1 {
+ index = firstMulti
+ }
+ return index, s
+ }
+
+ decompSet := makeDecompSet()
+
+ // Store the uniqued decompositions in a byte buffer,
+ // preceded by their byte length.
+ for _, c := range chars {
+ for _, f := range c.forms {
+ if len(f.expandedDecomp) == 0 {
+ continue
+ }
+ if f.combinesBackward {
+ logger.Fatalf("%U: combinesBackward and decompose", c.codePoint)
+ }
+ index, s := mkstr(c.codePoint, &f)
+ decompSet.insert(index, s)
+ }
+ }
+
+ decompositions := bytes.NewBuffer(make([]byte, 0, 10000))
+ size := 0
+ positionMap := make(map[string]uint16)
+ decompositions.WriteString("\000")
+ fmt.Println("const (")
+ for i, m := range decompSet {
+ sa := []string{}
+ for s := range m {
+ sa = append(sa, s)
+ }
+ sort.Strings(sa)
+ for _, s := range sa {
+ p := decompositions.Len()
+ decompositions.WriteString(s)
+ positionMap[s] = uint16(p)
+ }
+ if cname[i] != "" {
+ fmt.Printf("%s = 0x%X\n", cname[i], decompositions.Len())
+ }
+ }
+ fmt.Println("maxDecomp = 0x8000")
+ fmt.Println(")")
+ b := decompositions.Bytes()
+ printBytes(b, "decomps")
+ size += len(b)
+
+ varnames := []string{"nfc", "nfkc"}
+ for i := 0; i < FNumberOfFormTypes; i++ {
+ trie := newNode()
+ for r, c := range chars {
+ f := c.forms[i]
+ d := f.expandedDecomp
+ if len(d) != 0 {
+ _, key := mkstr(c.codePoint, &f)
+ trie.insert(rune(r), positionMap[key])
+ if c.ccc != ccc(d[0]) {
+ // We assume the lead ccc of a decomposition !=0 in this case.
+ if ccc(d[0]) == 0 {
+ logger.Fatalf("Expected leading CCC to be non-zero; ccc is %d", c.ccc)
+ }
+ }
+ } else if v := makeEntry(&f)<<8 | uint16(c.ccc); v != 0 {
+ trie.insert(c.codePoint, 0x8000|v)
+ }
+ }
+ size += trie.printTables(varnames[i])
+ }
+ return size
+}
+
+func contains(sa []string, s string) bool {
+ for _, a := range sa {
+ if a == s {
+ return true
+ }
+ }
+ return false
+}
+
+// Extract the version number from the URL.
+func version() string {
+ // From http://www.unicode.org/standard/versions/#Version_Numbering:
+ // for the later Unicode versions, data files are located in
+ // versioned directories.
+ fields := strings.Split(*url, "/")
+ for _, f := range fields {
+ if match, _ := regexp.MatchString(`[0-9]\.[0-9]\.[0-9]`, f); match {
+ return f
+ }
+ }
+ logger.Fatal("unknown version")
+ return "Unknown"
+}
+
+const fileHeader = `// Generated by running
+// maketables --tables=%s --url=%s
+// DO NOT EDIT
+
+package norm
+
+`
+
+func makeTables() {
+ size := 0
+ if *tablelist == "" {
+ return
+ }
+ list := strings.Split(*tablelist, ",")
+ if *tablelist == "all" {
+ list = []string{"recomp", "info"}
+ }
+ fmt.Printf(fileHeader, *tablelist, *url)
+
+ fmt.Println("// Version is the Unicode edition from which the tables are derived.")
+ fmt.Printf("const Version = %q\n\n", version())
+
+ if contains(list, "info") {
+ size += printCharInfoTables()
+ }
+
+ if contains(list, "recomp") {
+ // Note that we use 32 bit keys, instead of 64 bit.
+ // This clips the bits of three entries, but we know
+ // this won't cause a collision. The compiler will catch
+ // any changes made to UnicodeData.txt that introduces
+ // a collision.
+ // Note that the recomposition map for NFC and NFKC
+ // are identical.
+
+ // Recomposition map
+ nrentries := 0
+ for _, c := range chars {
+ f := c.forms[FCanonical]
+ if !f.isOneWay && len(f.decomp) > 0 {
+ nrentries++
+ }
+ }
+ sz := nrentries * 8
+ size += sz
+ fmt.Printf("// recompMap: %d bytes (entries only)\n", sz)
+ fmt.Println("var recompMap = map[uint32]rune{")
+ for i, c := range chars {
+ f := c.forms[FCanonical]
+ d := f.decomp
+ if !f.isOneWay && len(d) > 0 {
+ key := uint32(uint16(d[0]))<<16 + uint32(uint16(d[1]))
+ fmt.Printf("0x%.8X: 0x%.4X,\n", key, i)
+ }
+ }
+ fmt.Printf("}\n\n")
+ }
+
+ fmt.Printf("// Total size of tables: %dKB (%d bytes)\n", (size+512)/1024, size)
+}
+
+func printChars() {
+ if *verbose {
+ for _, c := range chars {
+ if !c.isValid() || c.state == SMissing {
+ continue
+ }
+ fmt.Println(c)
+ }
+ }
+}
+
+// verifyComputed does various consistency tests.
+func verifyComputed() {
+ for i, c := range chars {
+ for _, f := range c.forms {
+ isNo := (f.quickCheck[MDecomposed] == QCNo)
+ if (len(f.decomp) > 0) != isNo && !isHangul(rune(i)) {
+ log.Fatalf("%U: NF*D must be no if rune decomposes", i)
+ }
+
+ isMaybe := f.quickCheck[MComposed] == QCMaybe
+ if f.combinesBackward != isMaybe {
+ log.Fatalf("%U: NF*C must be maybe if combinesBackward", i)
+ }
+ }
+ nfc := c.forms[FCanonical]
+ nfkc := c.forms[FCompatibility]
+ if nfc.combinesBackward != nfkc.combinesBackward {
+ logger.Fatalf("%U: Cannot combine combinesBackward\n", c.codePoint)
+ }
+ }
+}
+
+var qcRe = regexp.MustCompile(`([0-9A-F\.]+) *; (NF.*_QC); ([YNM]) #.*`)
+
+// Use values in DerivedNormalizationProps.txt to compare against the
+// values we computed.
+// DerivedNormalizationProps.txt has form:
+// 00C0..00C5 ; NFD_QC; N # ...
+// 0374 ; NFD_QC; N # ...
+// See http://unicode.org/reports/tr44/ for full explanation
+func testDerived() {
+ if !*test {
+ return
+ }
+ f := openReader("DerivedNormalizationProps.txt")
+ defer f.Close()
+ scanner := bufio.NewScanner(f)
+ for scanner.Scan() {
+ line := scanner.Text()
+ qc := qcRe.FindStringSubmatch(line)
+ if qc == nil {
+ continue
+ }
+ rng := strings.Split(qc[1], "..")
+ i, err := strconv.ParseUint(rng[0], 16, 64)
+ if err != nil {
+ log.Fatal(err)
+ }
+ j := i
+ if len(rng) > 1 {
+ j, err = strconv.ParseUint(rng[1], 16, 64)
+ if err != nil {
+ log.Fatal(err)
+ }
+ }
+ var ftype, mode int
+ qt := strings.TrimSpace(qc[2])
+ switch qt {
+ case "NFC_QC":
+ ftype, mode = FCanonical, MComposed
+ case "NFD_QC":
+ ftype, mode = FCanonical, MDecomposed
+ case "NFKC_QC":
+ ftype, mode = FCompatibility, MComposed
+ case "NFKD_QC":
+ ftype, mode = FCompatibility, MDecomposed
+ default:
+ log.Fatalf(`Unexpected quick check type "%s"`, qt)
+ }
+ var qr QCResult
+ switch qc[3] {
+ case "Y":
+ qr = QCYes
+ case "N":
+ qr = QCNo
+ case "M":
+ qr = QCMaybe
+ default:
+ log.Fatalf(`Unexpected quick check value "%s"`, qc[3])
+ }
+ var lastFailed bool
+ // Verify current
+ for ; i <= j; i++ {
+ c := &chars[int(i)]
+ c.forms[ftype].verified[mode] = true
+ curqr := c.forms[ftype].quickCheck[mode]
+ if curqr != qr {
+ if !lastFailed {
+ logger.Printf("%s: %.4X..%.4X -- %s\n",
+ qt, int(i), int(j), line[0:50])
+ }
+ logger.Printf("%U: FAILED %s (was %v need %v)\n",
+ int(i), qt, curqr, qr)
+ lastFailed = true
+ }
+ }
+ }
+ if scanner.Err() != nil {
+ logger.Fatal(scanner.Err())
+ }
+ // Any unspecified value must be QCYes. Verify this.
+ for i, c := range chars {
+ for j, fd := range c.forms {
+ for k, qr := range fd.quickCheck {
+ if !fd.verified[k] && qr != QCYes {
+ m := "%U: FAIL F:%d M:%d (was %v need Yes) %s\n"
+ logger.Printf(m, i, j, k, qr, c.name)
+ }
+ }
+ }
+ }
+}
diff --git a/src/pkg/exp/norm/maketesttables.go b/src/pkg/exp/norm/maketesttables.go
new file mode 100644
index 000000000..6d11ec069
--- /dev/null
+++ b/src/pkg/exp/norm/maketesttables.go
@@ -0,0 +1,45 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// Generate test data for trie code.
+
+package main
+
+import (
+ "fmt"
+)
+
+func main() {
+ printTestTables()
+}
+
+// We take the smallest, largest and an arbitrary value for each
+// of the UTF-8 sequence lengths.
+var testRunes = []rune{
+ 0x01, 0x0C, 0x7F, // 1-byte sequences
+ 0x80, 0x100, 0x7FF, // 2-byte sequences
+ 0x800, 0x999, 0xFFFF, // 3-byte sequences
+ 0x10000, 0x10101, 0x10FFFF, // 4-byte sequences
+ 0x200, 0x201, 0x202, 0x210, 0x215, // five entries in one sparse block
+}
+
+const fileHeader = `// Generated by running
+// maketesttables
+// DO NOT EDIT
+
+package norm
+
+`
+
+func printTestTables() {
+ fmt.Print(fileHeader)
+ fmt.Printf("var testRunes = %#v\n\n", testRunes)
+ t := newNode()
+ for i, r := range testRunes {
+ t.insert(r, uint16(i))
+ }
+ t.printTables("testdata")
+}
diff --git a/src/pkg/exp/norm/norm_test.go b/src/pkg/exp/norm/norm_test.go
new file mode 100644
index 000000000..12dacfcf3
--- /dev/null
+++ b/src/pkg/exp/norm/norm_test.go
@@ -0,0 +1,14 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm_test
+
+import (
+ "testing"
+)
+
+func TestPlaceHolder(t *testing.T) {
+ // Does nothing, just allows the Makefile to be canonical
+ // while waiting for the package itself to be written.
+}
diff --git a/src/pkg/exp/norm/normalize.go b/src/pkg/exp/norm/normalize.go
new file mode 100644
index 000000000..1c3e49b77
--- /dev/null
+++ b/src/pkg/exp/norm/normalize.go
@@ -0,0 +1,478 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package norm contains types and functions for normalizing Unicode strings.
+package norm
+
+import "unicode/utf8"
+
+// A Form denotes a canonical representation of Unicode code points.
+// The Unicode-defined normalization and equivalence forms are:
+//
+// NFC Unicode Normalization Form C
+// NFD Unicode Normalization Form D
+// NFKC Unicode Normalization Form KC
+// NFKD Unicode Normalization Form KD
+//
+// For a Form f, this documentation uses the notation f(x) to mean
+// the bytes or string x converted to the given form.
+// A position n in x is called a boundary if conversion to the form can
+// proceed independently on both sides:
+// f(x) == append(f(x[0:n]), f(x[n:])...)
+//
+// References: http://unicode.org/reports/tr15/ and
+// http://unicode.org/notes/tn5/.
+type Form int
+
+const (
+ NFC Form = iota
+ NFD
+ NFKC
+ NFKD
+)
+
+// Bytes returns f(b). May return b if f(b) = b.
+func (f Form) Bytes(b []byte) []byte {
+ rb := reorderBuffer{}
+ rb.init(f, b)
+ n := quickSpan(&rb, 0)
+ if n == len(b) {
+ return b
+ }
+ out := make([]byte, n, len(b))
+ copy(out, b[0:n])
+ return doAppend(&rb, out, n)
+}
+
+// String returns f(s).
+func (f Form) String(s string) string {
+ rb := reorderBuffer{}
+ rb.initString(f, s)
+ n := quickSpan(&rb, 0)
+ if n == len(s) {
+ return s
+ }
+ out := make([]byte, n, len(s))
+ copy(out, s[0:n])
+ return string(doAppend(&rb, out, n))
+}
+
+// IsNormal returns true if b == f(b).
+func (f Form) IsNormal(b []byte) bool {
+ rb := reorderBuffer{}
+ rb.init(f, b)
+ bp := quickSpan(&rb, 0)
+ if bp == len(b) {
+ return true
+ }
+ for bp < len(b) {
+ decomposeSegment(&rb, bp)
+ if rb.f.composing {
+ rb.compose()
+ }
+ for i := 0; i < rb.nrune; i++ {
+ info := rb.rune[i]
+ if bp+int(info.size) > len(b) {
+ return false
+ }
+ p := info.pos
+ pe := p + info.size
+ for ; p < pe; p++ {
+ if b[bp] != rb.byte[p] {
+ return false
+ }
+ bp++
+ }
+ }
+ rb.reset()
+ bp = quickSpan(&rb, bp)
+ }
+ return true
+}
+
+// IsNormalString returns true if s == f(s).
+func (f Form) IsNormalString(s string) bool {
+ rb := reorderBuffer{}
+ rb.initString(f, s)
+ bp := quickSpan(&rb, 0)
+ if bp == len(s) {
+ return true
+ }
+ for bp < len(s) {
+ decomposeSegment(&rb, bp)
+ if rb.f.composing {
+ rb.compose()
+ }
+ for i := 0; i < rb.nrune; i++ {
+ info := rb.rune[i]
+ if bp+int(info.size) > len(s) {
+ return false
+ }
+ p := info.pos
+ pe := p + info.size
+ for ; p < pe; p++ {
+ if s[bp] != rb.byte[p] {
+ return false
+ }
+ bp++
+ }
+ }
+ rb.reset()
+ bp = quickSpan(&rb, bp)
+ }
+ return true
+}
+
+// patchTail fixes a case where a rune may be incorrectly normalized
+// if it is followed by illegal continuation bytes. It returns the
+// patched buffer and whether there were trailing continuation bytes.
+func patchTail(rb *reorderBuffer, buf []byte) ([]byte, bool) {
+ info, p := lastRuneStart(&rb.f, buf)
+ if p == -1 || info.size == 0 {
+ return buf, false
+ }
+ end := p + int(info.size)
+ extra := len(buf) - end
+ if extra > 0 {
+ // Potentially allocating memory. However, this only
+ // happens with ill-formed UTF-8.
+ x := make([]byte, 0)
+ x = append(x, buf[len(buf)-extra:]...)
+ buf = decomposeToLastBoundary(rb, buf[:end])
+ if rb.f.composing {
+ rb.compose()
+ }
+ buf = rb.flush(buf)
+ return append(buf, x...), true
+ }
+ return buf, false
+}
+
+func appendQuick(rb *reorderBuffer, dst []byte, i int) ([]byte, int) {
+ if rb.nsrc == i {
+ return dst, i
+ }
+ end := quickSpan(rb, i)
+ return rb.src.appendSlice(dst, i, end), end
+}
+
+// Append returns f(append(out, b...)).
+// The buffer out must be nil, empty, or equal to f(out).
+func (f Form) Append(out []byte, src ...byte) []byte {
+ if len(src) == 0 {
+ return out
+ }
+ rb := reorderBuffer{}
+ rb.init(f, src)
+ return doAppend(&rb, out, 0)
+}
+
+func doAppend(rb *reorderBuffer, out []byte, p int) []byte {
+ src, n := rb.src, rb.nsrc
+ doMerge := len(out) > 0
+ if q := src.skipNonStarter(p); q > p {
+ // Move leading non-starters to destination.
+ out = src.appendSlice(out, p, q)
+ buf, endsInError := patchTail(rb, out)
+ if endsInError {
+ out = buf
+ doMerge = false // no need to merge, ends with illegal UTF-8
+ } else {
+ out = decomposeToLastBoundary(rb, buf) // force decomposition
+ }
+ p = q
+ }
+ fd := &rb.f
+ if doMerge {
+ var info Properties
+ if p < n {
+ info = fd.info(src, p)
+ if p == 0 && !info.BoundaryBefore() {
+ out = decomposeToLastBoundary(rb, out)
+ }
+ }
+ if info.size == 0 || info.BoundaryBefore() {
+ if fd.composing {
+ rb.compose()
+ }
+ out = rb.flush(out)
+ if info.size == 0 {
+ // Append incomplete UTF-8 encoding.
+ return src.appendSlice(out, p, n)
+ }
+ }
+ }
+ if rb.nrune == 0 {
+ out, p = appendQuick(rb, out, p)
+ }
+ for p < n {
+ p = decomposeSegment(rb, p)
+ if fd.composing {
+ rb.compose()
+ }
+ out = rb.flush(out)
+ out, p = appendQuick(rb, out, p)
+ }
+ return out
+}
+
+// AppendString returns f(append(out, []byte(s))).
+// The buffer out must be nil, empty, or equal to f(out).
+func (f Form) AppendString(out []byte, src string) []byte {
+ if len(src) == 0 {
+ return out
+ }
+ rb := reorderBuffer{}
+ rb.initString(f, src)
+ return doAppend(&rb, out, 0)
+}
+
+// QuickSpan returns a boundary n such that b[0:n] == f(b[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) QuickSpan(b []byte) int {
+ rb := reorderBuffer{}
+ rb.init(f, b)
+ n := quickSpan(&rb, 0)
+ return n
+}
+
+func quickSpan(rb *reorderBuffer, i int) int {
+ var lastCC uint8
+ var nc int
+ lastSegStart := i
+ src, n := rb.src, rb.nsrc
+ for i < n {
+ if j := src.skipASCII(i, n); i != j {
+ i = j
+ lastSegStart = i - 1
+ lastCC = 0
+ nc = 0
+ continue
+ }
+ info := rb.f.info(src, i)
+ if info.size == 0 {
+ // include incomplete runes
+ return n
+ }
+ cc := info.ccc
+ if rb.f.composing {
+ if !info.isYesC() {
+ break
+ }
+ } else {
+ if !info.isYesD() {
+ break
+ }
+ }
+ if cc == 0 {
+ lastSegStart = i
+ nc = 0
+ } else {
+ if nc >= maxCombiningChars {
+ lastSegStart = i
+ lastCC = cc
+ nc = 1
+ } else {
+ if lastCC > cc {
+ return lastSegStart
+ }
+ nc++
+ }
+ }
+ lastCC = cc
+ i += int(info.size)
+ }
+ if i == n {
+ return n
+ }
+ if rb.f.composing {
+ return lastSegStart
+ }
+ return i
+}
+
+// QuickSpanString returns a boundary n such that b[0:n] == f(s[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) QuickSpanString(s string) int {
+ rb := reorderBuffer{}
+ rb.initString(f, s)
+ return quickSpan(&rb, 0)
+}
+
+// FirstBoundary returns the position i of the first boundary in b
+// or -1 if b contains no boundary.
+func (f Form) FirstBoundary(b []byte) int {
+ rb := reorderBuffer{}
+ rb.init(f, b)
+ return firstBoundary(&rb)
+}
+
+func firstBoundary(rb *reorderBuffer) int {
+ src, nsrc := rb.src, rb.nsrc
+ i := src.skipNonStarter(0)
+ if i >= nsrc {
+ return -1
+ }
+ fd := &rb.f
+ info := fd.info(src, i)
+ for n := 0; info.size != 0 && !info.BoundaryBefore(); {
+ i += int(info.size)
+ if n++; n >= maxCombiningChars {
+ return i
+ }
+ if i >= nsrc {
+ if !info.BoundaryAfter() {
+ return -1
+ }
+ return nsrc
+ }
+ info = fd.info(src, i)
+ }
+ if info.size == 0 {
+ return -1
+ }
+ return i
+}
+
+// FirstBoundaryInString returns the position i of the first boundary in s
+// or -1 if s contains no boundary.
+func (f Form) FirstBoundaryInString(s string) int {
+ rb := reorderBuffer{}
+ rb.initString(f, s)
+ return firstBoundary(&rb)
+}
+
+// LastBoundary returns the position i of the last boundary in b
+// or -1 if b contains no boundary.
+func (f Form) LastBoundary(b []byte) int {
+ return lastBoundary(formTable[f], b)
+}
+
+func lastBoundary(fd *formInfo, b []byte) int {
+ i := len(b)
+ info, p := lastRuneStart(fd, b)
+ if p == -1 {
+ return -1
+ }
+ if info.size == 0 { // ends with incomplete rune
+ if p == 0 { // starts with incomplete rune
+ return -1
+ }
+ i = p
+ info, p = lastRuneStart(fd, b[:i])
+ if p == -1 { // incomplete UTF-8 encoding or non-starter bytes without a starter
+ return i
+ }
+ }
+ if p+int(info.size) != i { // trailing non-starter bytes: illegal UTF-8
+ return i
+ }
+ if info.BoundaryAfter() {
+ return i
+ }
+ i = p
+ for n := 0; i >= 0 && !info.BoundaryBefore(); {
+ info, p = lastRuneStart(fd, b[:i])
+ if n++; n >= maxCombiningChars {
+ return len(b)
+ }
+ if p+int(info.size) != i {
+ if p == -1 { // no boundary found
+ return -1
+ }
+ return i // boundary after an illegal UTF-8 encoding
+ }
+ i = p
+ }
+ return i
+}
+
+// decomposeSegment scans the first segment in src into rb.
+// It returns the number of bytes consumed from src.
+// TODO(mpvl): consider inserting U+034f (Combining Grapheme Joiner)
+// when we detect a sequence of 30+ non-starter chars.
+func decomposeSegment(rb *reorderBuffer, sp int) int {
+ // Force one character to be consumed.
+ info := rb.f.info(rb.src, sp)
+ if info.size == 0 {
+ return 0
+ }
+ for rb.insert(rb.src, sp, info) {
+ sp += int(info.size)
+ if sp >= rb.nsrc {
+ break
+ }
+ info = rb.f.info(rb.src, sp)
+ bound := info.BoundaryBefore()
+ if bound || info.size == 0 {
+ break
+ }
+ }
+ return sp
+}
+
+// lastRuneStart returns the runeInfo and position of the last
+// rune in buf or the zero runeInfo and -1 if no rune was found.
+func lastRuneStart(fd *formInfo, buf []byte) (Properties, int) {
+ p := len(buf) - 1
+ for ; p >= 0 && !utf8.RuneStart(buf[p]); p-- {
+ }
+ if p < 0 {
+ return Properties{}, -1
+ }
+ return fd.info(inputBytes(buf), p), p
+}
+
+// decomposeToLastBoundary finds an open segment at the end of the buffer
+// and scans it into rb. Returns the buffer minus the last segment.
+func decomposeToLastBoundary(rb *reorderBuffer, buf []byte) []byte {
+ fd := &rb.f
+ info, i := lastRuneStart(fd, buf)
+ if int(info.size) != len(buf)-i {
+ // illegal trailing continuation bytes
+ return buf
+ }
+ if info.BoundaryAfter() {
+ return buf
+ }
+ var add [maxBackRunes]Properties // stores runeInfo in reverse order
+ add[0] = info
+ padd := 1
+ n := 1
+ p := len(buf) - int(info.size)
+ for ; p >= 0 && !info.BoundaryBefore(); p -= int(info.size) {
+ info, i = lastRuneStart(fd, buf[:p])
+ if int(info.size) != p-i {
+ break
+ }
+ // Check that decomposition doesn't result in overflow.
+ if info.hasDecomposition() {
+ if isHangul(buf) {
+ i += int(info.size)
+ n++
+ } else {
+ dcomp := info.Decomposition()
+ for i := 0; i < len(dcomp); {
+ inf := rb.f.info(inputBytes(dcomp), i)
+ i += int(inf.size)
+ n++
+ }
+ }
+ } else {
+ n++
+ }
+ if n > maxBackRunes {
+ break
+ }
+ add[padd] = info
+ padd++
+ }
+ pp := p
+ for padd--; padd >= 0; padd-- {
+ info = add[padd]
+ rb.insert(inputBytes(buf), pp, info)
+ pp += int(info.size)
+ }
+ return buf[:p]
+}
diff --git a/src/pkg/exp/norm/normalize_test.go b/src/pkg/exp/norm/normalize_test.go
new file mode 100644
index 000000000..9a6b46e41
--- /dev/null
+++ b/src/pkg/exp/norm/normalize_test.go
@@ -0,0 +1,750 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+ "bytes"
+ "io"
+ "strings"
+ "testing"
+)
+
+type PositionTest struct {
+ input string
+ pos int
+ buffer string // expected contents of reorderBuffer, if applicable
+}
+
+type positionFunc func(rb *reorderBuffer, s string) int
+
+func runPosTests(t *testing.T, name string, f Form, fn positionFunc, tests []PositionTest) {
+ rb := reorderBuffer{}
+ rb.init(f, nil)
+ for i, test := range tests {
+ rb.reset()
+ rb.src = inputString(test.input)
+ rb.nsrc = len(test.input)
+ pos := fn(&rb, test.input)
+ if pos != test.pos {
+ t.Errorf("%s:%d: position is %d; want %d", name, i, pos, test.pos)
+ }
+ runes := []rune(test.buffer)
+ if rb.nrune != len(runes) {
+ t.Errorf("%s:%d: reorder buffer length is %d; want %d", name, i, rb.nrune, len(runes))
+ continue
+ }
+ for j, want := range runes {
+ found := rune(rb.runeAt(j))
+ if found != want {
+ t.Errorf("%s:%d: rune at %d is %U; want %U", name, i, j, found, want)
+ }
+ }
+ }
+}
+
+var decomposeSegmentTests = []PositionTest{
+ // illegal runes
+ {"\xC0", 0, ""},
+ {"\u00E0\x80", 2, "\u0061\u0300"},
+ // starter
+ {"a", 1, "a"},
+ {"ab", 1, "a"},
+ // starter + composing
+ {"a\u0300", 3, "a\u0300"},
+ {"a\u0300b", 3, "a\u0300"},
+ // with decomposition
+ {"\u00C0", 2, "A\u0300"},
+ {"\u00C0b", 2, "A\u0300"},
+ // long
+ {strings.Repeat("\u0300", 31), 62, strings.Repeat("\u0300", 31)},
+ // ends with incomplete UTF-8 encoding
+ {"\xCC", 0, ""},
+ {"\u0300\xCC", 2, "\u0300"},
+}
+
+func decomposeSegmentF(rb *reorderBuffer, s string) int {
+ rb.src = inputString(s)
+ rb.nsrc = len(s)
+ return decomposeSegment(rb, 0)
+}
+
+func TestDecomposeSegment(t *testing.T) {
+ runPosTests(t, "TestDecomposeSegment", NFC, decomposeSegmentF, decomposeSegmentTests)
+}
+
+var firstBoundaryTests = []PositionTest{
+ // no boundary
+ {"", -1, ""},
+ {"\u0300", -1, ""},
+ {"\x80\x80", -1, ""},
+ // illegal runes
+ {"\xff", 0, ""},
+ {"\u0300\xff", 2, ""},
+ {"\u0300\xc0\x80\x80", 2, ""},
+ // boundaries
+ {"a", 0, ""},
+ {"\u0300a", 2, ""},
+ // Hangul
+ {"\u1103\u1161", 0, ""},
+ {"\u110B\u1173\u11B7", 0, ""},
+ {"\u1161\u110B\u1173\u11B7", 3, ""},
+ {"\u1173\u11B7\u1103\u1161", 6, ""},
+ // too many combining characters.
+ {strings.Repeat("\u0300", maxCombiningChars-1), -1, ""},
+ {strings.Repeat("\u0300", maxCombiningChars), 60, ""},
+ {strings.Repeat("\u0300", maxCombiningChars+1), 60, ""},
+}
+
+func firstBoundaryF(rb *reorderBuffer, s string) int {
+ return rb.f.form.FirstBoundary([]byte(s))
+}
+
+func firstBoundaryStringF(rb *reorderBuffer, s string) int {
+ return rb.f.form.FirstBoundaryInString(s)
+}
+
+func TestFirstBoundary(t *testing.T) {
+ runPosTests(t, "TestFirstBoundary", NFC, firstBoundaryF, firstBoundaryTests)
+ runPosTests(t, "TestFirstBoundaryInString", NFC, firstBoundaryStringF, firstBoundaryTests)
+}
+
+var decomposeToLastTests = []PositionTest{
+ // ends with inert character
+ {"Hello!", 6, ""},
+ {"\u0632", 2, ""},
+ {"a\u0301\u0635", 5, ""},
+ // ends with non-inert starter
+ {"a", 0, "a"},
+ {"a\u0301a", 3, "a"},
+ {"a\u0301\u03B9", 3, "\u03B9"},
+ {"a\u0327", 0, "a\u0327"},
+ // illegal runes
+ {"\xFF", 1, ""},
+ {"aa\xFF", 3, ""},
+ {"\xC0\x80\x80", 3, ""},
+ {"\xCC\x80\x80", 3, ""},
+ // ends with incomplete UTF-8 encoding
+ {"a\xCC", 2, ""},
+ // ends with combining characters
+ {"\u0300\u0301", 0, "\u0300\u0301"},
+ {"a\u0300\u0301", 0, "a\u0300\u0301"},
+ {"a\u0301\u0308", 0, "a\u0301\u0308"},
+ {"a\u0308\u0301", 0, "a\u0308\u0301"},
+ {"aaaa\u0300\u0301", 3, "a\u0300\u0301"},
+ {"\u0300a\u0300\u0301", 2, "a\u0300\u0301"},
+ {"\u00C0", 0, "A\u0300"},
+ {"a\u00C0", 1, "A\u0300"},
+ // decomposing
+ {"a\u0300\uFDC0", 3, "\u0645\u062C\u064A"},
+ {"\uFDC0" + strings.Repeat("\u0300", 26), 0, "\u0645\u062C\u064A" + strings.Repeat("\u0300", 26)},
+ // Hangul
+ {"a\u1103", 1, "\u1103"},
+ {"a\u110B", 1, "\u110B"},
+ {"a\u110B\u1173", 1, "\u110B\u1173"},
+ // See comment in composition.go:compBoundaryAfter.
+ {"a\u110B\u1173\u11B7", 1, "\u110B\u1173\u11B7"},
+ {"a\uC73C", 1, "\u110B\u1173"},
+ {"다음", 3, "\u110B\u1173\u11B7"},
+ {"다", 0, "\u1103\u1161"},
+ {"\u1103\u1161\u110B\u1173\u11B7", 6, "\u110B\u1173\u11B7"},
+ {"\u110B\u1173\u11B7\u1103\u1161", 9, "\u1103\u1161"},
+ {"다음음", 6, "\u110B\u1173\u11B7"},
+ {"음다다", 6, "\u1103\u1161"},
+ // buffer overflow
+ {"a" + strings.Repeat("\u0300", 30), 3, strings.Repeat("\u0300", 29)},
+ {"\uFDFA" + strings.Repeat("\u0300", 14), 3, strings.Repeat("\u0300", 14)},
+ // weird UTF-8
+ {"a\u0300\u11B7", 0, "a\u0300\u11B7"},
+}
+
+func decomposeToLast(rb *reorderBuffer, s string) int {
+ buf := decomposeToLastBoundary(rb, []byte(s))
+ return len(buf)
+}
+
+func TestDecomposeToLastBoundary(t *testing.T) {
+ runPosTests(t, "TestDecomposeToLastBoundary", NFKC, decomposeToLast, decomposeToLastTests)
+}
+
+var lastBoundaryTests = []PositionTest{
+ // ends with inert character
+ {"Hello!", 6, ""},
+ {"\u0632", 2, ""},
+ // ends with non-inert starter
+ {"a", 0, ""},
+ // illegal runes
+ {"\xff", 1, ""},
+ {"aa\xff", 3, ""},
+ {"a\xff\u0300", 1, ""},
+ {"\xc0\x80\x80", 3, ""},
+ {"\xc0\x80\x80\u0300", 3, ""},
+ // ends with incomplete UTF-8 encoding
+ {"\xCC", -1, ""},
+ {"\xE0\x80", -1, ""},
+ {"\xF0\x80\x80", -1, ""},
+ {"a\xCC", 0, ""},
+ {"\x80\xCC", 1, ""},
+ {"\xCC\xCC", 1, ""},
+ // ends with combining characters
+ {"a\u0300\u0301", 0, ""},
+ {"aaaa\u0300\u0301", 3, ""},
+ {"\u0300a\u0300\u0301", 2, ""},
+ {"\u00C0", 0, ""},
+ {"a\u00C0", 1, ""},
+ // decomposition may recombine
+ {"\u0226", 0, ""},
+ // no boundary
+ {"", -1, ""},
+ {"\u0300\u0301", -1, ""},
+ {"\u0300", -1, ""},
+ {"\x80\x80", -1, ""},
+ {"\x80\x80\u0301", -1, ""},
+ // Hangul
+ {"다음", 3, ""},
+ {"다", 0, ""},
+ {"\u1103\u1161\u110B\u1173\u11B7", 6, ""},
+ {"\u110B\u1173\u11B7\u1103\u1161", 9, ""},
+ // too many combining characters.
+ {strings.Repeat("\u0300", maxCombiningChars-1), -1, ""},
+ {strings.Repeat("\u0300", maxCombiningChars), 60, ""},
+ {strings.Repeat("\u0300", maxCombiningChars+1), 62, ""},
+}
+
+func lastBoundaryF(rb *reorderBuffer, s string) int {
+ return rb.f.form.LastBoundary([]byte(s))
+}
+
+func TestLastBoundary(t *testing.T) {
+ runPosTests(t, "TestLastBoundary", NFC, lastBoundaryF, lastBoundaryTests)
+}
+
+var quickSpanTests = []PositionTest{
+ {"", 0, ""},
+ // starters
+ {"a", 1, ""},
+ {"abc", 3, ""},
+ {"\u043Eb", 3, ""},
+ // incomplete last rune.
+ {"\xCC", 1, ""},
+ {"a\xCC", 2, ""},
+ // incorrectly ordered combining characters
+ {"\u0300\u0316", 0, ""},
+ {"\u0300\u0316cd", 0, ""},
+ // have a maximum number of combining characters.
+ {strings.Repeat("\u035D", 30) + "\u035B", 62, ""},
+ {"a" + strings.Repeat("\u035D", 30) + "\u035B", 63, ""},
+ {"Ɵ" + strings.Repeat("\u035D", 30) + "\u035B", 64, ""},
+ {"aa" + strings.Repeat("\u035D", 30) + "\u035B", 64, ""},
+}
+
+var quickSpanNFDTests = []PositionTest{
+ // needs decomposing
+ {"\u00C0", 0, ""},
+ {"abc\u00C0", 3, ""},
+ // correctly ordered combining characters
+ {"\u0300", 2, ""},
+ {"ab\u0300", 4, ""},
+ {"ab\u0300cd", 6, ""},
+ {"\u0300cd", 4, ""},
+ {"\u0316\u0300", 4, ""},
+ {"ab\u0316\u0300", 6, ""},
+ {"ab\u0316\u0300cd", 8, ""},
+ {"ab\u0316\u0300\u00C0", 6, ""},
+ {"\u0316\u0300cd", 6, ""},
+ {"\u043E\u0308b", 5, ""},
+ // incorrectly ordered combining characters
+ {"ab\u0300\u0316", 1, ""}, // TODO: we could skip 'b' as well.
+ {"ab\u0300\u0316cd", 1, ""},
+ // Hangul
+ {"같은", 0, ""},
+}
+
+var quickSpanNFCTests = []PositionTest{
+ // okay composed
+ {"\u00C0", 2, ""},
+ {"abc\u00C0", 5, ""},
+ // correctly ordered combining characters
+ {"ab\u0300", 1, ""},
+ {"ab\u0300cd", 1, ""},
+ {"ab\u0316\u0300", 1, ""},
+ {"ab\u0316\u0300cd", 1, ""},
+ {"\u00C0\u035D", 4, ""},
+ // we do not special case leading combining characters
+ {"\u0300cd", 0, ""},
+ {"\u0300", 0, ""},
+ {"\u0316\u0300", 0, ""},
+ {"\u0316\u0300cd", 0, ""},
+ // incorrectly ordered combining characters
+ {"ab\u0300\u0316", 1, ""},
+ {"ab\u0300\u0316cd", 1, ""},
+ // Hangul
+ {"같은", 6, ""},
+}
+
+func doQuickSpan(rb *reorderBuffer, s string) int {
+ return rb.f.form.QuickSpan([]byte(s))
+}
+
+func doQuickSpanString(rb *reorderBuffer, s string) int {
+ return rb.f.form.QuickSpanString(s)
+}
+
+func TestQuickSpan(t *testing.T) {
+ runPosTests(t, "TestQuickSpanNFD1", NFD, doQuickSpan, quickSpanTests)
+ runPosTests(t, "TestQuickSpanNFD2", NFD, doQuickSpan, quickSpanNFDTests)
+ runPosTests(t, "TestQuickSpanNFC1", NFC, doQuickSpan, quickSpanTests)
+ runPosTests(t, "TestQuickSpanNFC2", NFC, doQuickSpan, quickSpanNFCTests)
+
+ runPosTests(t, "TestQuickSpanStringNFD1", NFD, doQuickSpanString, quickSpanTests)
+ runPosTests(t, "TestQuickSpanStringNFD2", NFD, doQuickSpanString, quickSpanNFDTests)
+ runPosTests(t, "TestQuickSpanStringNFC1", NFC, doQuickSpanString, quickSpanTests)
+ runPosTests(t, "TestQuickSpanStringNFC2", NFC, doQuickSpanString, quickSpanNFCTests)
+}
+
+var isNormalTests = []PositionTest{
+ {"", 1, ""},
+ // illegal runes
+ {"\xff", 1, ""},
+ // starters
+ {"a", 1, ""},
+ {"abc", 1, ""},
+ {"\u043Eb", 1, ""},
+ // incorrectly ordered combining characters
+ {"\u0300\u0316", 0, ""},
+ {"ab\u0300\u0316", 0, ""},
+ {"ab\u0300\u0316cd", 0, ""},
+ {"\u0300\u0316cd", 0, ""},
+}
+var isNormalNFDTests = []PositionTest{
+ // needs decomposing
+ {"\u00C0", 0, ""},
+ {"abc\u00C0", 0, ""},
+ // correctly ordered combining characters
+ {"\u0300", 1, ""},
+ {"ab\u0300", 1, ""},
+ {"ab\u0300cd", 1, ""},
+ {"\u0300cd", 1, ""},
+ {"\u0316\u0300", 1, ""},
+ {"ab\u0316\u0300", 1, ""},
+ {"ab\u0316\u0300cd", 1, ""},
+ {"\u0316\u0300cd", 1, ""},
+ {"\u043E\u0308b", 1, ""},
+ // Hangul
+ {"같은", 0, ""},
+}
+var isNormalNFCTests = []PositionTest{
+ // okay composed
+ {"\u00C0", 1, ""},
+ {"abc\u00C0", 1, ""},
+ // need reordering
+ {"a\u0300", 0, ""},
+ {"a\u0300cd", 0, ""},
+ {"a\u0316\u0300", 0, ""},
+ {"a\u0316\u0300cd", 0, ""},
+ // correctly ordered combining characters
+ {"ab\u0300", 1, ""},
+ {"ab\u0300cd", 1, ""},
+ {"ab\u0316\u0300", 1, ""},
+ {"ab\u0316\u0300cd", 1, ""},
+ {"\u00C0\u035D", 1, ""},
+ {"\u0300", 1, ""},
+ {"\u0316\u0300cd", 1, ""},
+ // Hangul
+ {"같은", 1, ""},
+}
+
+func isNormalF(rb *reorderBuffer, s string) int {
+ if rb.f.form.IsNormal([]byte(s)) {
+ return 1
+ }
+ return 0
+}
+
+func TestIsNormal(t *testing.T) {
+ runPosTests(t, "TestIsNormalNFD1", NFD, isNormalF, isNormalTests)
+ runPosTests(t, "TestIsNormalNFD2", NFD, isNormalF, isNormalNFDTests)
+ runPosTests(t, "TestIsNormalNFC1", NFC, isNormalF, isNormalTests)
+ runPosTests(t, "TestIsNormalNFC2", NFC, isNormalF, isNormalNFCTests)
+}
+
+type AppendTest struct {
+ left string
+ right string
+ out string
+}
+
+type appendFunc func(f Form, out []byte, s string) []byte
+
+func runAppendTests(t *testing.T, name string, f Form, fn appendFunc, tests []AppendTest) {
+ for i, test := range tests {
+ out := []byte(test.left)
+ out = fn(f, out, test.right)
+ outs := string(out)
+ if len(outs) != len(test.out) {
+ t.Errorf("%s:%d: length is %d; want %d", name, i, len(outs), len(test.out))
+ }
+ if outs != test.out {
+ // Find first rune that differs and show context.
+ ir := []rune(outs)
+ ig := []rune(test.out)
+ for j := 0; j < len(ir) && j < len(ig); j++ {
+ if ir[j] == ig[j] {
+ continue
+ }
+ if j -= 3; j < 0 {
+ j = 0
+ }
+ for e := j + 7; j < e && j < len(ir) && j < len(ig); j++ {
+ t.Errorf("%s:%d: runeAt(%d) = %U; want %U", name, i, j, ir[j], ig[j])
+ }
+ break
+ }
+ }
+ }
+}
+
+var appendTests = []AppendTest{
+ // empty buffers
+ {"", "", ""},
+ {"a", "", "a"},
+ {"", "a", "a"},
+ {"", "\u0041\u0307\u0304", "\u01E0"},
+ // segment split across buffers
+ {"", "a\u0300b", "\u00E0b"},
+ {"a", "\u0300b", "\u00E0b"},
+ {"a", "\u0300\u0316", "\u00E0\u0316"},
+ {"a", "\u0316\u0300", "\u00E0\u0316"},
+ {"a", "\u0300a\u0300", "\u00E0\u00E0"},
+ {"a", "\u0300a\u0300a\u0300", "\u00E0\u00E0\u00E0"},
+ {"a", "\u0300aaa\u0300aaa\u0300", "\u00E0aa\u00E0aa\u00E0"},
+ {"a\u0300", "\u0327", "\u00E0\u0327"},
+ {"a\u0327", "\u0300", "\u00E0\u0327"},
+ {"a\u0316", "\u0300", "\u00E0\u0316"},
+ {"\u0041\u0307", "\u0304", "\u01E0"},
+ // Hangul
+ {"", "\u110B\u1173", "\uC73C"},
+ {"", "\u1103\u1161", "\uB2E4"},
+ {"", "\u110B\u1173\u11B7", "\uC74C"},
+ {"", "\u320E", "\x28\uAC00\x29"},
+ {"", "\x28\u1100\u1161\x29", "\x28\uAC00\x29"},
+ {"\u1103", "\u1161", "\uB2E4"},
+ {"\u110B", "\u1173\u11B7", "\uC74C"},
+ {"\u110B\u1173", "\u11B7", "\uC74C"},
+ {"\uC73C", "\u11B7", "\uC74C"},
+ // UTF-8 encoding split across buffers
+ {"a\xCC", "\x80", "\u00E0"},
+ {"a\xCC", "\x80b", "\u00E0b"},
+ {"a\xCC", "\x80a\u0300", "\u00E0\u00E0"},
+ {"a\xCC", "\x80\x80", "\u00E0\x80"},
+ {"a\xCC", "\x80\xCC", "\u00E0\xCC"},
+ {"a\u0316\xCC", "\x80a\u0316\u0300", "\u00E0\u0316\u00E0\u0316"},
+ // ending in incomplete UTF-8 encoding
+ {"", "\xCC", "\xCC"},
+ {"a", "\xCC", "a\xCC"},
+ {"a", "b\xCC", "ab\xCC"},
+ {"\u0226", "\xCC", "\u0226\xCC"},
+ // illegal runes
+ {"", "\x80", "\x80"},
+ {"", "\x80\x80\x80", "\x80\x80\x80"},
+ {"", "\xCC\x80\x80\x80", "\xCC\x80\x80\x80"},
+ {"", "a\x80", "a\x80"},
+ {"", "a\x80\x80\x80", "a\x80\x80\x80"},
+ {"", "a\x80\x80\x80\x80\x80\x80", "a\x80\x80\x80\x80\x80\x80"},
+ {"a", "\x80\x80\x80", "a\x80\x80\x80"},
+ // overflow
+ {"", strings.Repeat("\x80", 33), strings.Repeat("\x80", 33)},
+ {strings.Repeat("\x80", 33), "", strings.Repeat("\x80", 33)},
+ {strings.Repeat("\x80", 33), strings.Repeat("\x80", 33), strings.Repeat("\x80", 66)},
+ // overflow of combining characters
+ {strings.Repeat("\u0300", 33), "", strings.Repeat("\u0300", 33)},
+ // weird UTF-8
+ {"\u00E0\xE1", "\x86", "\u00E0\xE1\x86"},
+ {"a\u0300\u11B7", "\u0300", "\u00E0\u11B7\u0300"},
+ {"a\u0300\u11B7\u0300", "\u0300", "\u00E0\u11B7\u0300\u0300"},
+ {"\u0300", "\xF8\x80\x80\x80\x80\u0300", "\u0300\xF8\x80\x80\x80\x80\u0300"},
+ {"\u0300", "\xFC\x80\x80\x80\x80\x80\u0300", "\u0300\xFC\x80\x80\x80\x80\x80\u0300"},
+ {"\xF8\x80\x80\x80\x80\u0300", "\u0300", "\xF8\x80\x80\x80\x80\u0300\u0300"},
+ {"\xFC\x80\x80\x80\x80\x80\u0300", "\u0300", "\xFC\x80\x80\x80\x80\x80\u0300\u0300"},
+ {"\xF8\x80\x80\x80", "\x80\u0300\u0300", "\xF8\x80\x80\x80\x80\u0300\u0300"},
+}
+
+func appendF(f Form, out []byte, s string) []byte {
+ return f.Append(out, []byte(s)...)
+}
+
+func appendStringF(f Form, out []byte, s string) []byte {
+ return f.AppendString(out, s)
+}
+
+func bytesF(f Form, out []byte, s string) []byte {
+ buf := []byte{}
+ buf = append(buf, out...)
+ buf = append(buf, s...)
+ return f.Bytes(buf)
+}
+
+func stringF(f Form, out []byte, s string) []byte {
+ outs := string(out) + s
+ return []byte(f.String(outs))
+}
+
+func TestAppend(t *testing.T) {
+ runAppendTests(t, "TestAppend", NFKC, appendF, appendTests)
+ runAppendTests(t, "TestAppendString", NFKC, appendStringF, appendTests)
+ runAppendTests(t, "TestBytes", NFKC, bytesF, appendTests)
+ runAppendTests(t, "TestString", NFKC, stringF, appendTests)
+}
+
+func appendBench(f Form, in []byte) func() {
+ buf := make([]byte, 0, 4*len(in))
+ return func() {
+ f.Append(buf, in...)
+ }
+}
+
+func iterBench(f Form, in []byte) func() {
+ iter := Iter{}
+ return func() {
+ iter.Init(f, in)
+ for !iter.Done() {
+ iter.Next()
+ }
+ }
+}
+
+func readerBench(f Form, in []byte) func() {
+ buf := make([]byte, 4*len(in))
+ return func() {
+ r := f.Reader(bytes.NewReader(in))
+ var err error
+ for err == nil {
+ _, err = r.Read(buf)
+ }
+ if err != io.EOF {
+ panic("")
+ }
+ }
+}
+
+func writerBench(f Form, in []byte) func() {
+ buf := make([]byte, 0, 4*len(in))
+ return func() {
+ r := f.Writer(bytes.NewBuffer(buf))
+ if _, err := r.Write(in); err != nil {
+ panic("")
+ }
+ }
+}
+
+func appendBenchmarks(bm []func(), f Form, in []byte) []func() {
+ //bm = append(bm, appendBench(f, in))
+ bm = append(bm, iterBench(f, in))
+ //bm = append(bm, readerBench(f, in))
+ //bm = append(bm, writerBench(f, in))
+ return bm
+}
+
+func doFormBenchmark(b *testing.B, inf, f Form, s string) {
+ b.StopTimer()
+ in := inf.Bytes([]byte(s))
+ bm := appendBenchmarks(nil, f, in)
+ b.SetBytes(int64(len(in) * len(bm)))
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ for _, fn := range bm {
+ fn()
+ }
+ }
+}
+
+var ascii = strings.Repeat("There is nothing to change here! ", 500)
+
+func BenchmarkNormalizeAsciiNFC(b *testing.B) {
+ doFormBenchmark(b, NFC, NFC, ascii)
+}
+func BenchmarkNormalizeAsciiNFD(b *testing.B) {
+ doFormBenchmark(b, NFC, NFD, ascii)
+}
+func BenchmarkNormalizeAsciiNFKC(b *testing.B) {
+ doFormBenchmark(b, NFC, NFKC, ascii)
+}
+func BenchmarkNormalizeAsciiNFKD(b *testing.B) {
+ doFormBenchmark(b, NFC, NFKD, ascii)
+}
+
+func BenchmarkNormalizeNFC2NFC(b *testing.B) {
+ doFormBenchmark(b, NFC, NFC, txt_all)
+}
+func BenchmarkNormalizeNFC2NFD(b *testing.B) {
+ doFormBenchmark(b, NFC, NFD, txt_all)
+}
+func BenchmarkNormalizeNFD2NFC(b *testing.B) {
+ doFormBenchmark(b, NFD, NFC, txt_all)
+}
+func BenchmarkNormalizeNFD2NFD(b *testing.B) {
+ doFormBenchmark(b, NFD, NFD, txt_all)
+}
+
+// Hangul is often special-cased, so we test it separately.
+func BenchmarkNormalizeHangulNFC2NFC(b *testing.B) {
+ doFormBenchmark(b, NFC, NFC, txt_kr)
+}
+func BenchmarkNormalizeHangulNFC2NFD(b *testing.B) {
+ doFormBenchmark(b, NFC, NFD, txt_kr)
+}
+func BenchmarkNormalizeHangulNFD2NFC(b *testing.B) {
+ doFormBenchmark(b, NFD, NFC, txt_kr)
+}
+func BenchmarkNormalizeHangulNFD2NFD(b *testing.B) {
+ doFormBenchmark(b, NFD, NFD, txt_kr)
+}
+
+var forms = []Form{NFC, NFD, NFKC, NFKD}
+
+func doTextBenchmark(b *testing.B, s string) {
+ b.StopTimer()
+ in := []byte(s)
+ bm := []func(){}
+ for _, f := range forms {
+ bm = appendBenchmarks(bm, f, in)
+ }
+ b.SetBytes(int64(len(s) * len(bm)))
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ for _, f := range bm {
+ f()
+ }
+ }
+}
+
+func BenchmarkCanonicalOrdering(b *testing.B) {
+ doTextBenchmark(b, txt_canon)
+}
+func BenchmarkExtendedLatin(b *testing.B) {
+ doTextBenchmark(b, txt_vn)
+}
+func BenchmarkMiscTwoByteUtf8(b *testing.B) {
+ doTextBenchmark(b, twoByteUtf8)
+}
+func BenchmarkMiscThreeByteUtf8(b *testing.B) {
+ doTextBenchmark(b, threeByteUtf8)
+}
+func BenchmarkHangul(b *testing.B) {
+ doTextBenchmark(b, txt_kr)
+}
+func BenchmarkJapanese(b *testing.B) {
+ doTextBenchmark(b, txt_jp)
+}
+func BenchmarkChinese(b *testing.B) {
+ doTextBenchmark(b, txt_cn)
+}
+func BenchmarkOverflow(b *testing.B) {
+ doTextBenchmark(b, overflow)
+}
+
+var overflow = string(bytes.Repeat([]byte("\u035D"), 4096)) + "\u035B"
+
+// Tests sampled from the Canonical ordering tests (Part 2) of
+// http://unicode.org/Public/UNIDATA/NormalizationTest.txt
+const txt_canon = `\u0061\u0315\u0300\u05AE\u0300\u0062 \u0061\u0300\u0315\u0300\u05AE\u0062
+\u0061\u0302\u0315\u0300\u05AE\u0062 \u0061\u0307\u0315\u0300\u05AE\u0062
+\u0061\u0315\u0300\u05AE\u030A\u0062 \u0061\u059A\u0316\u302A\u031C\u0062
+\u0061\u032E\u059A\u0316\u302A\u0062 \u0061\u0338\u093C\u0334\u0062
+\u0061\u059A\u0316\u302A\u0339 \u0061\u0341\u0315\u0300\u05AE\u0062
+\u0061\u0348\u059A\u0316\u302A\u0062 \u0061\u0361\u0345\u035D\u035C\u0062
+\u0061\u0366\u0315\u0300\u05AE\u0062 \u0061\u0315\u0300\u05AE\u0486\u0062
+\u0061\u05A4\u059A\u0316\u302A\u0062 \u0061\u0315\u0300\u05AE\u0613\u0062
+\u0061\u0315\u0300\u05AE\u0615\u0062 \u0061\u0617\u0315\u0300\u05AE\u0062
+\u0061\u0619\u0618\u064D\u064E\u0062 \u0061\u0315\u0300\u05AE\u0654\u0062
+\u0061\u0315\u0300\u05AE\u06DC\u0062 \u0061\u0733\u0315\u0300\u05AE\u0062
+\u0061\u0744\u059A\u0316\u302A\u0062 \u0061\u0315\u0300\u05AE\u0745\u0062
+\u0061\u09CD\u05B0\u094D\u3099\u0062 \u0061\u0E38\u0E48\u0E38\u0C56\u0062
+\u0061\u0EB8\u0E48\u0E38\u0E49\u0062 \u0061\u0F72\u0F71\u0EC8\u0F71\u0062
+\u0061\u1039\u05B0\u094D\u3099\u0062 \u0061\u05B0\u094D\u3099\u1A60\u0062
+\u0061\u3099\u093C\u0334\u1BE6\u0062 \u0061\u3099\u093C\u0334\u1C37\u0062
+\u0061\u1CD9\u059A\u0316\u302A\u0062 \u0061\u2DED\u0315\u0300\u05AE\u0062
+\u0061\u2DEF\u0315\u0300\u05AE\u0062 \u0061\u302D\u302E\u059A\u0316\u0062`
+
+// Taken from http://creativecommons.org/licenses/by-sa/3.0/vn/
+const txt_vn = `Với các điều kiện sau: Ghi nhận công của tác giả.
+Nếu bạn sử dụng, chuyển đổi, hoặc xây dựng dự án từ
+nội dung được chia sẻ này, bạn phải áp dụng giấy phép này hoặc
+một giấy phép khác có các điều khoản tương tự như giấy phép này
+cho dự án của bạn. Hiểu rằng: Miễn — Bất kỳ các điều kiện nào
+trên đây cũng có thể được miễn bỏ nếu bạn được sự cho phép của
+người sở hữu bản quyền. Phạm vi công chúng — Khi tác phẩm hoặc
+bất kỳ chương nào của tác phẩm đã trong vùng dành cho công
+chúng theo quy định của pháp luật thì tình trạng của nó không
+bị ảnh hưởng bởi giấy phép trong bất kỳ trường hợp nào.`
+
+// Taken from http://creativecommons.org/licenses/by-sa/1.0/deed.ru
+const txt_ru = `При обязательном соблюдении следующих условий:
+Attribution — Вы должны атрибутировать произведение (указывать
+автора и источник) в порядке, предусмотренном автором или
+лицензиаром (но только так, чтобы никоим образом не подразумевалось,
+что они поддерживают вас или использование вами данного произведения).
+Υπό τις ακόλουθες προϋποθέσεις:`
+
+// Taken from http://creativecommons.org/licenses/by-sa/3.0/gr/
+const txt_gr = `Αναφορά Δημιουργού — Θα πρέπει να κάνετε την αναφορά στο έργο με τον
+τρόπο που έχει οριστεί από το δημιουργό ή το χορηγούντο την άδεια
+(χωρίς όμως να εννοείται με οποιονδήποτε τρόπο ότι εγκρίνουν εσάς ή
+τη χρήση του έργου από εσάς). Παρόμοια Διανομή — Εάν αλλοιώσετε,
+τροποποιήσετε ή δημιουργήσετε περαιτέρω βασισμένοι στο έργο θα
+μπορείτε να διανέμετε το έργο που θα προκύψει μόνο με την ίδια ή
+παρόμοια άδεια.`
+
+// Taken from http://creativecommons.org/licenses/by-sa/3.0/deed.ar
+const txt_ar = `بموجب الشروط التالية نسب المصنف — يجب عليك أن
+تنسب العمل بالطريقة التي تحددها المؤلف أو المرخص (ولكن ليس بأي حال من
+الأحوال أن توحي وتقترح بتحول أو استخدامك للعمل).
+المشاركة على قدم المساواة — إذا كنت يعدل ، والتغيير ، أو الاستفادة
+من هذا العمل ، قد ينتج عن توزيع العمل إلا في ظل تشابه او تطابق فى واحد
+لهذا الترخيص.`
+
+// Taken from http://creativecommons.org/licenses/by-sa/1.0/il/
+const txt_il = `בכפוף לתנאים הבאים: ייחוס — עליך לייחס את היצירה (לתת קרדיט) באופן
+המצויין על-ידי היוצר או מעניק הרישיון (אך לא בשום אופן המרמז על כך
+שהם תומכים בך או בשימוש שלך ביצירה). שיתוף זהה — אם תחליט/י לשנות,
+לעבד או ליצור יצירה נגזרת בהסתמך על יצירה זו, תוכל/י להפיץ את יצירתך
+החדשה רק תחת אותו הרישיון או רישיון דומה לרישיון זה.`
+
+const twoByteUtf8 = txt_ru + txt_gr + txt_ar + txt_il
+
+// Taken from http://creativecommons.org/licenses/by-sa/2.0/kr/
+const txt_kr = `다음과 같은 조건을 따라야 합니다: 저작자표시
+(Attribution) — 저작자나 이용허락자가 정한 방법으로 저작물의
+원저작자를 표시하여야 합니다(그러나 원저작자가 이용자나 이용자의
+이용을 보증하거나 추천한다는 의미로 표시해서는 안됩니다).
+동일조건변경허락 — 이 저작물을 이용하여 만든 이차적 저작물에는 본
+라이선스와 동일한 라이선스를 적용해야 합니다.`
+
+// Taken from http://creativecommons.org/licenses/by-sa/3.0/th/
+const txt_th = `ภายใต้เงื่อนไข ดังต่อไปนี้ : แสดงที่มา — คุณต้องแสดงที่
+มาของงานดังกล่าว ตามรูปแบบที่ผู้สร้างสรรค์หรือผู้อนุญาตกำหนด (แต่
+ไม่ใช่ในลักษณะที่ว่า พวกเขาสนับสนุนคุณหรือสนับสนุนการที่
+คุณนำงานไปใช้) อนุญาตแบบเดียวกัน — หากคุณดัดแปลง เปลี่ยนรูป หรื
+อต่อเติมงานนี้ คุณต้องใช้สัญญาอนุญาตแบบเดียวกันหรือแบบที่เหมื
+อนกับสัญญาอนุญาตที่ใช้กับงานนี้เท่านั้น`
+
+const threeByteUtf8 = txt_th
+
+// Taken from http://creativecommons.org/licenses/by-sa/2.0/jp/
+const txt_jp = `あなたの従うべき条件は以下の通りです。
+表示 — あなたは原著作者のクレジットを表示しなければなりません。
+継承 — もしあなたがこの作品を改変、変形または加工した場合、
+あなたはその結果生じた作品をこの作品と同一の許諾条件の下でのみ
+頒布することができます。`
+
+// http://creativecommons.org/licenses/by-sa/2.5/cn/
+const txt_cn = `您可以自由： 复制、发行、展览、表演、放映、
+广播或通过信息网络传播本作品 创作演绎作品
+对本作品进行商业性使用 惟须遵守下列条件：
+署名 — 您必须按照作者或者许可人指定的方式对作品进行署名。
+相同方式共享 — 如果您改变、转换本作品或者以本作品为基础进行创作，
+您只能采用与本协议相同的许可协议发布基于本作品的演绎作品。`
+
+const txt_cjk = txt_cn + txt_jp + txt_kr
+const txt_all = txt_vn + twoByteUtf8 + threeByteUtf8 + txt_cjk
diff --git a/src/pkg/exp/norm/normregtest.go b/src/pkg/exp/norm/normregtest.go
new file mode 100644
index 000000000..b77b5b545
--- /dev/null
+++ b/src/pkg/exp/norm/normregtest.go
@@ -0,0 +1,304 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "exp/norm"
+ "flag"
+ "fmt"
+ "log"
+ "net/http"
+ "os"
+ "path"
+ "regexp"
+ "runtime"
+ "strconv"
+ "strings"
+ "time"
+ "unicode"
+ "unicode/utf8"
+)
+
+func main() {
+ flag.Parse()
+ loadTestData()
+ CharacterByCharacterTests()
+ StandardTests()
+ PerformanceTest()
+ if errorCount == 0 {
+ fmt.Println("PASS")
+ }
+}
+
+const file = "NormalizationTest.txt"
+
+var url = flag.String("url",
+ "http://www.unicode.org/Public/"+unicode.Version+"/ucd/"+file,
+ "URL of Unicode database directory")
+var localFiles = flag.Bool("local",
+ false,
+ "data files have been copied to the current directory; for debugging only")
+
+var logger = log.New(os.Stderr, "", log.Lshortfile)
+
+// This regression test runs the test set in NormalizationTest.txt
+// (taken from http://www.unicode.org/Public/<unicode.Version>/ucd/).
+//
+// NormalizationTest.txt has form:
+// @Part0 # Specific cases
+// #
+// 1E0A;1E0A;0044 0307;1E0A;0044 0307; # (Ḋ; Ḋ; D◌̇; Ḋ; D◌̇; ) LATIN CAPITAL LETTER D WITH DOT ABOVE
+// 1E0C;1E0C;0044 0323;1E0C;0044 0323; # (Ḍ; Ḍ; D◌̣; Ḍ; D◌̣; ) LATIN CAPITAL LETTER D WITH DOT BELOW
+//
+// Each test has 5 columns (c1, c2, c3, c4, c5), where
+// (c1, c2, c3, c4, c5) == (c1, NFC(c1), NFD(c1), NFKC(c1), NFKD(c1))
+//
+// CONFORMANCE:
+// 1. The following invariants must be true for all conformant implementations
+//
+// NFC
+// c2 == NFC(c1) == NFC(c2) == NFC(c3)
+// c4 == NFC(c4) == NFC(c5)
+//
+// NFD
+// c3 == NFD(c1) == NFD(c2) == NFD(c3)
+// c5 == NFD(c4) == NFD(c5)
+//
+// NFKC
+// c4 == NFKC(c1) == NFKC(c2) == NFKC(c3) == NFKC(c4) == NFKC(c5)
+//
+// NFKD
+// c5 == NFKD(c1) == NFKD(c2) == NFKD(c3) == NFKD(c4) == NFKD(c5)
+//
+// 2. For every code point X assigned in this version of Unicode that is not
+// specifically listed in Part 1, the following invariants must be true
+// for all conformant implementations:
+//
+// X == NFC(X) == NFD(X) == NFKC(X) == NFKD(X)
+//
+
+// Column types.
+const (
+ cRaw = iota
+ cNFC
+ cNFD
+ cNFKC
+ cNFKD
+ cMaxColumns
+)
+
+// Holds data from NormalizationTest.txt
+var part []Part
+
+type Part struct {
+ name string
+ number int
+ tests []Test
+}
+
+type Test struct {
+ name string
+ partnr int
+ number int
+ r rune // used for character by character test
+ cols [cMaxColumns]string // Each has 5 entries, see below.
+}
+
+func (t Test) Name() string {
+ if t.number < 0 {
+ return part[t.partnr].name
+ }
+ return fmt.Sprintf("%s:%d", part[t.partnr].name, t.number)
+}
+
+var partRe = regexp.MustCompile(`@Part(\d) # (.*)$`)
+var testRe = regexp.MustCompile(`^` + strings.Repeat(`([\dA-F ]+);`, 5) + ` # (.*)$`)
+
+var counter int
+
+// Load the data form NormalizationTest.txt
+func loadTestData() {
+ if *localFiles {
+ pwd, _ := os.Getwd()
+ *url = "file://" + path.Join(pwd, file)
+ }
+ t := &http.Transport{}
+ t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
+ c := &http.Client{Transport: t}
+ resp, err := c.Get(*url)
+ if err != nil {
+ logger.Fatal(err)
+ }
+ if resp.StatusCode != 200 {
+ logger.Fatal("bad GET status for "+file, resp.Status)
+ }
+ f := resp.Body
+ defer f.Close()
+ scanner := bufio.NewScanner(f)
+ for scanner.Scan() {
+ line := scanner.Text()
+ if len(line) == 0 || line[0] == '#' {
+ continue
+ }
+ m := partRe.FindStringSubmatch(line)
+ if m != nil {
+ if len(m) < 3 {
+ logger.Fatal("Failed to parse Part: ", line)
+ }
+ i, err := strconv.Atoi(m[1])
+ if err != nil {
+ logger.Fatal(err)
+ }
+ name := m[2]
+ part = append(part, Part{name: name[:len(name)-1], number: i})
+ continue
+ }
+ m = testRe.FindStringSubmatch(line)
+ if m == nil || len(m) < 7 {
+ logger.Fatalf(`Failed to parse: "%s" result: %#v`, line, m)
+ }
+ test := Test{name: m[6], partnr: len(part) - 1, number: counter}
+ counter++
+ for j := 1; j < len(m)-1; j++ {
+ for _, split := range strings.Split(m[j], " ") {
+ r, err := strconv.ParseUint(split, 16, 64)
+ if err != nil {
+ logger.Fatal(err)
+ }
+ if test.r == 0 {
+ // save for CharacterByCharacterTests
+ test.r = rune(r)
+ }
+ var buf [utf8.UTFMax]byte
+ sz := utf8.EncodeRune(buf[:], rune(r))
+ test.cols[j-1] += string(buf[:sz])
+ }
+ }
+ part := &part[len(part)-1]
+ part.tests = append(part.tests, test)
+ }
+ if scanner.Err() != nil {
+ logger.Fatal(scanner.Err())
+ }
+}
+
+var fstr = []string{"NFC", "NFD", "NFKC", "NFKD"}
+
+var errorCount int
+
+func cmpResult(t *Test, name string, f norm.Form, gold, test, result string) {
+ if gold != result {
+ errorCount++
+ if errorCount > 20 {
+ return
+ }
+ st, sr, sg := []rune(test), []rune(result), []rune(gold)
+ logger.Printf("%s:%s: %s(%X)=%X; want:%X: %s",
+ t.Name(), name, fstr[f], st, sr, sg, t.name)
+ }
+}
+
+func cmpIsNormal(t *Test, name string, f norm.Form, test string, result, want bool) {
+ if result != want {
+ errorCount++
+ if errorCount > 20 {
+ return
+ }
+ logger.Printf("%s:%s: %s(%X)=%v; want: %v", t.Name(), name, fstr[f], []rune(test), result, want)
+ }
+}
+
+func doTest(t *Test, f norm.Form, gold, test string) {
+ result := f.Bytes([]byte(test))
+ cmpResult(t, "Bytes", f, gold, test, string(result))
+ sresult := f.String(test)
+ cmpResult(t, "String", f, gold, test, sresult)
+ acc := []byte{}
+ i := norm.Iter{}
+ i.InitString(f, test)
+ for !i.Done() {
+ acc = append(acc, i.Next()...)
+ }
+ cmpResult(t, "Iter.Next", f, gold, test, string(acc))
+ for i := range test {
+ out := f.Append(f.Bytes([]byte(test[:i])), []byte(test[i:])...)
+ cmpResult(t, fmt.Sprintf(":Append:%d", i), f, gold, test, string(out))
+ }
+ cmpIsNormal(t, "IsNormal", f, test, f.IsNormal([]byte(test)), test == gold)
+}
+
+func doConformanceTests(t *Test, partn int) {
+ for i := 0; i <= 2; i++ {
+ doTest(t, norm.NFC, t.cols[1], t.cols[i])
+ doTest(t, norm.NFD, t.cols[2], t.cols[i])
+ doTest(t, norm.NFKC, t.cols[3], t.cols[i])
+ doTest(t, norm.NFKD, t.cols[4], t.cols[i])
+ }
+ for i := 3; i <= 4; i++ {
+ doTest(t, norm.NFC, t.cols[3], t.cols[i])
+ doTest(t, norm.NFD, t.cols[4], t.cols[i])
+ doTest(t, norm.NFKC, t.cols[3], t.cols[i])
+ doTest(t, norm.NFKD, t.cols[4], t.cols[i])
+ }
+}
+
+func CharacterByCharacterTests() {
+ tests := part[1].tests
+ var last rune = 0
+ for i := 0; i <= len(tests); i++ { // last one is special case
+ var r rune
+ if i == len(tests) {
+ r = 0x2FA1E // Don't have to go to 0x10FFFF
+ } else {
+ r = tests[i].r
+ }
+ for last++; last < r; last++ {
+ // Check all characters that were not explicitly listed in the test.
+ t := &Test{partnr: 1, number: -1}
+ char := string(last)
+ doTest(t, norm.NFC, char, char)
+ doTest(t, norm.NFD, char, char)
+ doTest(t, norm.NFKC, char, char)
+ doTest(t, norm.NFKD, char, char)
+ }
+ if i < len(tests) {
+ doConformanceTests(&tests[i], 1)
+ }
+ }
+}
+
+func StandardTests() {
+ for _, j := range []int{0, 2, 3} {
+ for _, test := range part[j].tests {
+ doConformanceTests(&test, j)
+ }
+ }
+}
+
+// PerformanceTest verifies that normalization is O(n). If any of the
+// code does not properly check for maxCombiningChars, normalization
+// may exhibit O(n**2) behavior.
+func PerformanceTest() {
+ runtime.GOMAXPROCS(2)
+ success := make(chan bool, 1)
+ go func() {
+ buf := bytes.Repeat([]byte("\u035D"), 1024*1024)
+ buf = append(buf, "\u035B"...)
+ norm.NFC.Append(nil, buf...)
+ success <- true
+ }()
+ timeout := time.After(1 * time.Second)
+ select {
+ case <-success:
+ // test completed before the timeout
+ case <-timeout:
+ errorCount++
+ logger.Printf(`unexpectedly long time to complete PerformanceTest`)
+ }
+}
diff --git a/src/pkg/exp/norm/readwriter.go b/src/pkg/exp/norm/readwriter.go
new file mode 100644
index 000000000..2682894de
--- /dev/null
+++ b/src/pkg/exp/norm/readwriter.go
@@ -0,0 +1,126 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import "io"
+
+type normWriter struct {
+ rb reorderBuffer
+ w io.Writer
+ buf []byte
+}
+
+// Write implements the standard write interface. If the last characters are
+// not at a normalization boundary, the bytes will be buffered for the next
+// write. The remaining bytes will be written on close.
+func (w *normWriter) Write(data []byte) (n int, err error) {
+ // Process data in pieces to keep w.buf size bounded.
+ const chunk = 4000
+
+ for len(data) > 0 {
+ // Normalize into w.buf.
+ m := len(data)
+ if m > chunk {
+ m = chunk
+ }
+ w.rb.src = inputBytes(data[:m])
+ w.rb.nsrc = m
+ w.buf = doAppend(&w.rb, w.buf, 0)
+ data = data[m:]
+ n += m
+
+ // Write out complete prefix, save remainder.
+ // Note that lastBoundary looks back at most 30 runes.
+ i := lastBoundary(&w.rb.f, w.buf)
+ if i == -1 {
+ i = 0
+ }
+ if i > 0 {
+ if _, err = w.w.Write(w.buf[:i]); err != nil {
+ break
+ }
+ bn := copy(w.buf, w.buf[i:])
+ w.buf = w.buf[:bn]
+ }
+ }
+ return n, err
+}
+
+// Close forces data that remains in the buffer to be written.
+func (w *normWriter) Close() error {
+ if len(w.buf) > 0 {
+ _, err := w.w.Write(w.buf)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// Writer returns a new writer that implements Write(b)
+// by writing f(b) to w. The returned writer may use an
+// an internal buffer to maintain state across Write calls.
+// Calling its Close method writes any buffered data to w.
+func (f Form) Writer(w io.Writer) io.WriteCloser {
+ wr := &normWriter{rb: reorderBuffer{}, w: w}
+ wr.rb.init(f, nil)
+ return wr
+}
+
+type normReader struct {
+ rb reorderBuffer
+ r io.Reader
+ inbuf []byte
+ outbuf []byte
+ bufStart int
+ lastBoundary int
+ err error
+}
+
+// Read implements the standard read interface.
+func (r *normReader) Read(p []byte) (int, error) {
+ for {
+ if r.lastBoundary-r.bufStart > 0 {
+ n := copy(p, r.outbuf[r.bufStart:r.lastBoundary])
+ r.bufStart += n
+ if r.lastBoundary-r.bufStart > 0 {
+ return n, nil
+ }
+ return n, r.err
+ }
+ if r.err != nil {
+ return 0, r.err
+ }
+ outn := copy(r.outbuf, r.outbuf[r.lastBoundary:])
+ r.outbuf = r.outbuf[0:outn]
+ r.bufStart = 0
+
+ n, err := r.r.Read(r.inbuf)
+ r.rb.src = inputBytes(r.inbuf[0:n])
+ r.rb.nsrc, r.err = n, err
+ if n > 0 {
+ r.outbuf = doAppend(&r.rb, r.outbuf, 0)
+ }
+ if err == io.EOF {
+ r.lastBoundary = len(r.outbuf)
+ } else {
+ r.lastBoundary = lastBoundary(&r.rb.f, r.outbuf)
+ if r.lastBoundary == -1 {
+ r.lastBoundary = 0
+ }
+ }
+ }
+ panic("should not reach here")
+}
+
+// Reader returns a new reader that implements Read
+// by reading data from r and returning f(data).
+func (f Form) Reader(r io.Reader) io.Reader {
+ const chunk = 4000
+ buf := make([]byte, chunk)
+ rr := &normReader{rb: reorderBuffer{}, r: r, inbuf: buf}
+ rr.rb.init(f, buf)
+ return rr
+}
diff --git a/src/pkg/exp/norm/readwriter_test.go b/src/pkg/exp/norm/readwriter_test.go
new file mode 100644
index 000000000..3b49eb0a2
--- /dev/null
+++ b/src/pkg/exp/norm/readwriter_test.go
@@ -0,0 +1,68 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+ "bytes"
+ "fmt"
+ "strings"
+ "testing"
+)
+
+var ioTests = []AppendTest{
+ {"", strings.Repeat("a\u0316\u0300", 6), strings.Repeat("\u00E0\u0316", 6)},
+ {"", strings.Repeat("a\u0300\u0316", 4000), strings.Repeat("\u00E0\u0316", 4000)},
+ {"", strings.Repeat("\x80\x80", 4000), strings.Repeat("\x80\x80", 4000)},
+ {"", "\u0041\u0307\u0304", "\u01E0"},
+}
+
+var bufSizes = []int{1, 2, 3, 4, 5, 6, 7, 8, 100, 101, 102, 103, 4000, 4001, 4002, 4003}
+
+func readFunc(size int) appendFunc {
+ return func(f Form, out []byte, s string) []byte {
+ out = append(out, s...)
+ r := f.Reader(bytes.NewBuffer(out))
+ buf := make([]byte, size)
+ result := []byte{}
+ for n, err := 0, error(nil); err == nil; {
+ n, err = r.Read(buf)
+ result = append(result, buf[:n]...)
+ }
+ return result
+ }
+}
+
+func TestReader(t *testing.T) {
+ for _, s := range bufSizes {
+ name := fmt.Sprintf("TestReader%da", s)
+ runAppendTests(t, name, NFKC, readFunc(s), appendTests)
+ name = fmt.Sprintf("TestReader%db", s)
+ runAppendTests(t, name, NFKC, readFunc(s), ioTests)
+ }
+}
+
+func writeFunc(size int) appendFunc {
+ return func(f Form, out []byte, s string) []byte {
+ in := append(out, s...)
+ result := new(bytes.Buffer)
+ w := f.Writer(result)
+ buf := make([]byte, size)
+ for n := 0; len(in) > 0; in = in[n:] {
+ n = copy(buf, in)
+ _, _ = w.Write(buf[:n])
+ }
+ w.Close()
+ return result.Bytes()
+ }
+}
+
+func TestWriter(t *testing.T) {
+ for _, s := range bufSizes {
+ name := fmt.Sprintf("TestWriter%da", s)
+ runAppendTests(t, name, NFKC, writeFunc(s), appendTests)
+ name = fmt.Sprintf("TestWriter%db", s)
+ runAppendTests(t, name, NFKC, writeFunc(s), ioTests)
+ }
+}
diff --git a/src/pkg/exp/norm/tables.go b/src/pkg/exp/norm/tables.go
new file mode 100644
index 000000000..fa33a34a1
--- /dev/null
+++ b/src/pkg/exp/norm/tables.go
@@ -0,0 +1,6779 @@
+// Generated by running
+// maketables --tables=all --url=http://www.unicode.org/Public/6.2.0/ucd/
+// DO NOT EDIT
+
+package norm
+
+// Version is the Unicode edition from which the tables are derived.
+const Version = "6.2.0"
+
+const (
+ firstMulti = 0x18CF
+ firstCCC = 0x2E74
+ endMulti = 0x2F4A
+ firstLeadingCCC = 0x4994
+ firstCCCZeroExcept = 0x49AA
+ lastDecomp = 0x49D1
+ maxDecomp = 0x8000
+)
+
+// decomps: 18897 bytes
+var decomps = [...]byte{
+ // Bytes 0 - 3f
+ 0x00, 0x41, 0x20, 0x41, 0x21, 0x41, 0x22, 0x41,
+ 0x23, 0x41, 0x24, 0x41, 0x25, 0x41, 0x26, 0x41,
+ 0x27, 0x41, 0x28, 0x41, 0x29, 0x41, 0x2A, 0x41,
+ 0x2B, 0x41, 0x2C, 0x41, 0x2D, 0x41, 0x2E, 0x41,
+ 0x2F, 0x41, 0x30, 0x41, 0x31, 0x41, 0x32, 0x41,
+ 0x33, 0x41, 0x34, 0x41, 0x35, 0x41, 0x36, 0x41,
+ 0x37, 0x41, 0x38, 0x41, 0x39, 0x41, 0x3A, 0x41,
+ 0x3B, 0x41, 0x3C, 0x41, 0x3D, 0x41, 0x3E, 0x41,
+ // Bytes 40 - 7f
+ 0x3F, 0x41, 0x40, 0x41, 0x41, 0x41, 0x42, 0x41,
+ 0x43, 0x41, 0x44, 0x41, 0x45, 0x41, 0x46, 0x41,
+ 0x47, 0x41, 0x48, 0x41, 0x49, 0x41, 0x4A, 0x41,
+ 0x4B, 0x41, 0x4C, 0x41, 0x4D, 0x41, 0x4E, 0x41,
+ 0x4F, 0x41, 0x50, 0x41, 0x51, 0x41, 0x52, 0x41,
+ 0x53, 0x41, 0x54, 0x41, 0x55, 0x41, 0x56, 0x41,
+ 0x57, 0x41, 0x58, 0x41, 0x59, 0x41, 0x5A, 0x41,
+ 0x5B, 0x41, 0x5C, 0x41, 0x5D, 0x41, 0x5E, 0x41,
+ // Bytes 80 - bf
+ 0x5F, 0x41, 0x60, 0x41, 0x61, 0x41, 0x62, 0x41,
+ 0x63, 0x41, 0x64, 0x41, 0x65, 0x41, 0x66, 0x41,
+ 0x67, 0x41, 0x68, 0x41, 0x69, 0x41, 0x6A, 0x41,
+ 0x6B, 0x41, 0x6C, 0x41, 0x6D, 0x41, 0x6E, 0x41,
+ 0x6F, 0x41, 0x70, 0x41, 0x71, 0x41, 0x72, 0x41,
+ 0x73, 0x41, 0x74, 0x41, 0x75, 0x41, 0x76, 0x41,
+ 0x77, 0x41, 0x78, 0x41, 0x79, 0x41, 0x7A, 0x41,
+ 0x7B, 0x41, 0x7C, 0x41, 0x7D, 0x41, 0x7E, 0x42,
+ // Bytes c0 - ff
+ 0xC2, 0xA2, 0x42, 0xC2, 0xA3, 0x42, 0xC2, 0xA5,
+ 0x42, 0xC2, 0xA6, 0x42, 0xC2, 0xAC, 0x42, 0xC2,
+ 0xB4, 0x42, 0xC2, 0xB7, 0x42, 0xC3, 0x86, 0x42,
+ 0xC3, 0xB0, 0x42, 0xC4, 0xA6, 0x42, 0xC4, 0xA7,
+ 0x42, 0xC4, 0xB1, 0x42, 0xC5, 0x8B, 0x42, 0xC5,
+ 0x93, 0x42, 0xC6, 0x8E, 0x42, 0xC6, 0x90, 0x42,
+ 0xC6, 0xAB, 0x42, 0xC8, 0xA2, 0x42, 0xC8, 0xB7,
+ 0x42, 0xC9, 0x90, 0x42, 0xC9, 0x91, 0x42, 0xC9,
+ // Bytes 100 - 13f
+ 0x92, 0x42, 0xC9, 0x94, 0x42, 0xC9, 0x95, 0x42,
+ 0xC9, 0x99, 0x42, 0xC9, 0x9B, 0x42, 0xC9, 0x9C,
+ 0x42, 0xC9, 0x9F, 0x42, 0xC9, 0xA1, 0x42, 0xC9,
+ 0xA3, 0x42, 0xC9, 0xA5, 0x42, 0xC9, 0xA6, 0x42,
+ 0xC9, 0xA8, 0x42, 0xC9, 0xA9, 0x42, 0xC9, 0xAA,
+ 0x42, 0xC9, 0xAD, 0x42, 0xC9, 0xAF, 0x42, 0xC9,
+ 0xB0, 0x42, 0xC9, 0xB1, 0x42, 0xC9, 0xB2, 0x42,
+ 0xC9, 0xB3, 0x42, 0xC9, 0xB4, 0x42, 0xC9, 0xB5,
+ // Bytes 140 - 17f
+ 0x42, 0xC9, 0xB8, 0x42, 0xC9, 0xB9, 0x42, 0xC9,
+ 0xBB, 0x42, 0xCA, 0x81, 0x42, 0xCA, 0x82, 0x42,
+ 0xCA, 0x83, 0x42, 0xCA, 0x89, 0x42, 0xCA, 0x8A,
+ 0x42, 0xCA, 0x8B, 0x42, 0xCA, 0x8C, 0x42, 0xCA,
+ 0x90, 0x42, 0xCA, 0x91, 0x42, 0xCA, 0x92, 0x42,
+ 0xCA, 0x95, 0x42, 0xCA, 0x9D, 0x42, 0xCA, 0x9F,
+ 0x42, 0xCA, 0xB9, 0x42, 0xCE, 0x91, 0x42, 0xCE,
+ 0x92, 0x42, 0xCE, 0x93, 0x42, 0xCE, 0x94, 0x42,
+ // Bytes 180 - 1bf
+ 0xCE, 0x95, 0x42, 0xCE, 0x96, 0x42, 0xCE, 0x97,
+ 0x42, 0xCE, 0x98, 0x42, 0xCE, 0x99, 0x42, 0xCE,
+ 0x9A, 0x42, 0xCE, 0x9B, 0x42, 0xCE, 0x9C, 0x42,
+ 0xCE, 0x9D, 0x42, 0xCE, 0x9E, 0x42, 0xCE, 0x9F,
+ 0x42, 0xCE, 0xA0, 0x42, 0xCE, 0xA1, 0x42, 0xCE,
+ 0xA3, 0x42, 0xCE, 0xA4, 0x42, 0xCE, 0xA5, 0x42,
+ 0xCE, 0xA6, 0x42, 0xCE, 0xA7, 0x42, 0xCE, 0xA8,
+ 0x42, 0xCE, 0xA9, 0x42, 0xCE, 0xB1, 0x42, 0xCE,
+ // Bytes 1c0 - 1ff
+ 0xB2, 0x42, 0xCE, 0xB3, 0x42, 0xCE, 0xB4, 0x42,
+ 0xCE, 0xB5, 0x42, 0xCE, 0xB6, 0x42, 0xCE, 0xB7,
+ 0x42, 0xCE, 0xB8, 0x42, 0xCE, 0xB9, 0x42, 0xCE,
+ 0xBA, 0x42, 0xCE, 0xBB, 0x42, 0xCE, 0xBC, 0x42,
+ 0xCE, 0xBD, 0x42, 0xCE, 0xBE, 0x42, 0xCE, 0xBF,
+ 0x42, 0xCF, 0x80, 0x42, 0xCF, 0x81, 0x42, 0xCF,
+ 0x82, 0x42, 0xCF, 0x83, 0x42, 0xCF, 0x84, 0x42,
+ 0xCF, 0x85, 0x42, 0xCF, 0x86, 0x42, 0xCF, 0x87,
+ // Bytes 200 - 23f
+ 0x42, 0xCF, 0x88, 0x42, 0xCF, 0x89, 0x42, 0xCF,
+ 0x9C, 0x42, 0xCF, 0x9D, 0x42, 0xD0, 0xBD, 0x42,
+ 0xD7, 0x90, 0x42, 0xD7, 0x91, 0x42, 0xD7, 0x92,
+ 0x42, 0xD7, 0x93, 0x42, 0xD7, 0x94, 0x42, 0xD7,
+ 0x9B, 0x42, 0xD7, 0x9C, 0x42, 0xD7, 0x9D, 0x42,
+ 0xD7, 0xA2, 0x42, 0xD7, 0xA8, 0x42, 0xD7, 0xAA,
+ 0x42, 0xD8, 0xA1, 0x42, 0xD8, 0xA7, 0x42, 0xD8,
+ 0xA8, 0x42, 0xD8, 0xA9, 0x42, 0xD8, 0xAA, 0x42,
+ // Bytes 240 - 27f
+ 0xD8, 0xAB, 0x42, 0xD8, 0xAC, 0x42, 0xD8, 0xAD,
+ 0x42, 0xD8, 0xAE, 0x42, 0xD8, 0xAF, 0x42, 0xD8,
+ 0xB0, 0x42, 0xD8, 0xB1, 0x42, 0xD8, 0xB2, 0x42,
+ 0xD8, 0xB3, 0x42, 0xD8, 0xB4, 0x42, 0xD8, 0xB5,
+ 0x42, 0xD8, 0xB6, 0x42, 0xD8, 0xB7, 0x42, 0xD8,
+ 0xB8, 0x42, 0xD8, 0xB9, 0x42, 0xD8, 0xBA, 0x42,
+ 0xD9, 0x81, 0x42, 0xD9, 0x82, 0x42, 0xD9, 0x83,
+ 0x42, 0xD9, 0x84, 0x42, 0xD9, 0x85, 0x42, 0xD9,
+ // Bytes 280 - 2bf
+ 0x86, 0x42, 0xD9, 0x87, 0x42, 0xD9, 0x88, 0x42,
+ 0xD9, 0x89, 0x42, 0xD9, 0x8A, 0x42, 0xD9, 0xAE,
+ 0x42, 0xD9, 0xAF, 0x42, 0xD9, 0xB1, 0x42, 0xD9,
+ 0xB9, 0x42, 0xD9, 0xBA, 0x42, 0xD9, 0xBB, 0x42,
+ 0xD9, 0xBE, 0x42, 0xD9, 0xBF, 0x42, 0xDA, 0x80,
+ 0x42, 0xDA, 0x83, 0x42, 0xDA, 0x84, 0x42, 0xDA,
+ 0x86, 0x42, 0xDA, 0x87, 0x42, 0xDA, 0x88, 0x42,
+ 0xDA, 0x8C, 0x42, 0xDA, 0x8D, 0x42, 0xDA, 0x8E,
+ // Bytes 2c0 - 2ff
+ 0x42, 0xDA, 0x91, 0x42, 0xDA, 0x98, 0x42, 0xDA,
+ 0xA1, 0x42, 0xDA, 0xA4, 0x42, 0xDA, 0xA6, 0x42,
+ 0xDA, 0xA9, 0x42, 0xDA, 0xAD, 0x42, 0xDA, 0xAF,
+ 0x42, 0xDA, 0xB1, 0x42, 0xDA, 0xB3, 0x42, 0xDA,
+ 0xBA, 0x42, 0xDA, 0xBB, 0x42, 0xDA, 0xBE, 0x42,
+ 0xDB, 0x81, 0x42, 0xDB, 0x85, 0x42, 0xDB, 0x86,
+ 0x42, 0xDB, 0x87, 0x42, 0xDB, 0x88, 0x42, 0xDB,
+ 0x89, 0x42, 0xDB, 0x8B, 0x42, 0xDB, 0x8C, 0x42,
+ // Bytes 300 - 33f
+ 0xDB, 0x90, 0x42, 0xDB, 0x92, 0x43, 0xE0, 0xBC,
+ 0x8B, 0x43, 0xE1, 0x83, 0x9C, 0x43, 0xE1, 0x84,
+ 0x80, 0x43, 0xE1, 0x84, 0x81, 0x43, 0xE1, 0x84,
+ 0x82, 0x43, 0xE1, 0x84, 0x83, 0x43, 0xE1, 0x84,
+ 0x84, 0x43, 0xE1, 0x84, 0x85, 0x43, 0xE1, 0x84,
+ 0x86, 0x43, 0xE1, 0x84, 0x87, 0x43, 0xE1, 0x84,
+ 0x88, 0x43, 0xE1, 0x84, 0x89, 0x43, 0xE1, 0x84,
+ 0x8A, 0x43, 0xE1, 0x84, 0x8B, 0x43, 0xE1, 0x84,
+ // Bytes 340 - 37f
+ 0x8C, 0x43, 0xE1, 0x84, 0x8D, 0x43, 0xE1, 0x84,
+ 0x8E, 0x43, 0xE1, 0x84, 0x8F, 0x43, 0xE1, 0x84,
+ 0x90, 0x43, 0xE1, 0x84, 0x91, 0x43, 0xE1, 0x84,
+ 0x92, 0x43, 0xE1, 0x84, 0x94, 0x43, 0xE1, 0x84,
+ 0x95, 0x43, 0xE1, 0x84, 0x9A, 0x43, 0xE1, 0x84,
+ 0x9C, 0x43, 0xE1, 0x84, 0x9D, 0x43, 0xE1, 0x84,
+ 0x9E, 0x43, 0xE1, 0x84, 0xA0, 0x43, 0xE1, 0x84,
+ 0xA1, 0x43, 0xE1, 0x84, 0xA2, 0x43, 0xE1, 0x84,
+ // Bytes 380 - 3bf
+ 0xA3, 0x43, 0xE1, 0x84, 0xA7, 0x43, 0xE1, 0x84,
+ 0xA9, 0x43, 0xE1, 0x84, 0xAB, 0x43, 0xE1, 0x84,
+ 0xAC, 0x43, 0xE1, 0x84, 0xAD, 0x43, 0xE1, 0x84,
+ 0xAE, 0x43, 0xE1, 0x84, 0xAF, 0x43, 0xE1, 0x84,
+ 0xB2, 0x43, 0xE1, 0x84, 0xB6, 0x43, 0xE1, 0x85,
+ 0x80, 0x43, 0xE1, 0x85, 0x87, 0x43, 0xE1, 0x85,
+ 0x8C, 0x43, 0xE1, 0x85, 0x97, 0x43, 0xE1, 0x85,
+ 0x98, 0x43, 0xE1, 0x85, 0x99, 0x43, 0xE1, 0x85,
+ // Bytes 3c0 - 3ff
+ 0xA0, 0x43, 0xE1, 0x85, 0xA1, 0x43, 0xE1, 0x85,
+ 0xA2, 0x43, 0xE1, 0x85, 0xA3, 0x43, 0xE1, 0x85,
+ 0xA4, 0x43, 0xE1, 0x85, 0xA5, 0x43, 0xE1, 0x85,
+ 0xA6, 0x43, 0xE1, 0x85, 0xA7, 0x43, 0xE1, 0x85,
+ 0xA8, 0x43, 0xE1, 0x85, 0xA9, 0x43, 0xE1, 0x85,
+ 0xAA, 0x43, 0xE1, 0x85, 0xAB, 0x43, 0xE1, 0x85,
+ 0xAC, 0x43, 0xE1, 0x85, 0xAD, 0x43, 0xE1, 0x85,
+ 0xAE, 0x43, 0xE1, 0x85, 0xAF, 0x43, 0xE1, 0x85,
+ // Bytes 400 - 43f
+ 0xB0, 0x43, 0xE1, 0x85, 0xB1, 0x43, 0xE1, 0x85,
+ 0xB2, 0x43, 0xE1, 0x85, 0xB3, 0x43, 0xE1, 0x85,
+ 0xB4, 0x43, 0xE1, 0x85, 0xB5, 0x43, 0xE1, 0x86,
+ 0x84, 0x43, 0xE1, 0x86, 0x85, 0x43, 0xE1, 0x86,
+ 0x88, 0x43, 0xE1, 0x86, 0x91, 0x43, 0xE1, 0x86,
+ 0x92, 0x43, 0xE1, 0x86, 0x94, 0x43, 0xE1, 0x86,
+ 0x9E, 0x43, 0xE1, 0x86, 0xA1, 0x43, 0xE1, 0x86,
+ 0xAA, 0x43, 0xE1, 0x86, 0xAC, 0x43, 0xE1, 0x86,
+ // Bytes 440 - 47f
+ 0xAD, 0x43, 0xE1, 0x86, 0xB0, 0x43, 0xE1, 0x86,
+ 0xB1, 0x43, 0xE1, 0x86, 0xB2, 0x43, 0xE1, 0x86,
+ 0xB3, 0x43, 0xE1, 0x86, 0xB4, 0x43, 0xE1, 0x86,
+ 0xB5, 0x43, 0xE1, 0x87, 0x87, 0x43, 0xE1, 0x87,
+ 0x88, 0x43, 0xE1, 0x87, 0x8C, 0x43, 0xE1, 0x87,
+ 0x8E, 0x43, 0xE1, 0x87, 0x93, 0x43, 0xE1, 0x87,
+ 0x97, 0x43, 0xE1, 0x87, 0x99, 0x43, 0xE1, 0x87,
+ 0x9D, 0x43, 0xE1, 0x87, 0x9F, 0x43, 0xE1, 0x87,
+ // Bytes 480 - 4bf
+ 0xB1, 0x43, 0xE1, 0x87, 0xB2, 0x43, 0xE1, 0xB4,
+ 0x82, 0x43, 0xE1, 0xB4, 0x96, 0x43, 0xE1, 0xB4,
+ 0x97, 0x43, 0xE1, 0xB4, 0x9C, 0x43, 0xE1, 0xB4,
+ 0x9D, 0x43, 0xE1, 0xB4, 0xA5, 0x43, 0xE1, 0xB5,
+ 0xBB, 0x43, 0xE1, 0xB6, 0x85, 0x43, 0xE2, 0x80,
+ 0x82, 0x43, 0xE2, 0x80, 0x83, 0x43, 0xE2, 0x80,
+ 0x90, 0x43, 0xE2, 0x80, 0x93, 0x43, 0xE2, 0x80,
+ 0x94, 0x43, 0xE2, 0x82, 0xA9, 0x43, 0xE2, 0x86,
+ // Bytes 4c0 - 4ff
+ 0x90, 0x43, 0xE2, 0x86, 0x91, 0x43, 0xE2, 0x86,
+ 0x92, 0x43, 0xE2, 0x86, 0x93, 0x43, 0xE2, 0x88,
+ 0x82, 0x43, 0xE2, 0x88, 0x87, 0x43, 0xE2, 0x88,
+ 0x91, 0x43, 0xE2, 0x88, 0x92, 0x43, 0xE2, 0x94,
+ 0x82, 0x43, 0xE2, 0x96, 0xA0, 0x43, 0xE2, 0x97,
+ 0x8B, 0x43, 0xE2, 0xA6, 0x85, 0x43, 0xE2, 0xA6,
+ 0x86, 0x43, 0xE2, 0xB5, 0xA1, 0x43, 0xE3, 0x80,
+ 0x81, 0x43, 0xE3, 0x80, 0x82, 0x43, 0xE3, 0x80,
+ // Bytes 500 - 53f
+ 0x88, 0x43, 0xE3, 0x80, 0x89, 0x43, 0xE3, 0x80,
+ 0x8A, 0x43, 0xE3, 0x80, 0x8B, 0x43, 0xE3, 0x80,
+ 0x8C, 0x43, 0xE3, 0x80, 0x8D, 0x43, 0xE3, 0x80,
+ 0x8E, 0x43, 0xE3, 0x80, 0x8F, 0x43, 0xE3, 0x80,
+ 0x90, 0x43, 0xE3, 0x80, 0x91, 0x43, 0xE3, 0x80,
+ 0x92, 0x43, 0xE3, 0x80, 0x94, 0x43, 0xE3, 0x80,
+ 0x95, 0x43, 0xE3, 0x80, 0x96, 0x43, 0xE3, 0x80,
+ 0x97, 0x43, 0xE3, 0x82, 0xA1, 0x43, 0xE3, 0x82,
+ // Bytes 540 - 57f
+ 0xA2, 0x43, 0xE3, 0x82, 0xA3, 0x43, 0xE3, 0x82,
+ 0xA4, 0x43, 0xE3, 0x82, 0xA5, 0x43, 0xE3, 0x82,
+ 0xA6, 0x43, 0xE3, 0x82, 0xA7, 0x43, 0xE3, 0x82,
+ 0xA8, 0x43, 0xE3, 0x82, 0xA9, 0x43, 0xE3, 0x82,
+ 0xAA, 0x43, 0xE3, 0x82, 0xAB, 0x43, 0xE3, 0x82,
+ 0xAD, 0x43, 0xE3, 0x82, 0xAF, 0x43, 0xE3, 0x82,
+ 0xB1, 0x43, 0xE3, 0x82, 0xB3, 0x43, 0xE3, 0x82,
+ 0xB5, 0x43, 0xE3, 0x82, 0xB7, 0x43, 0xE3, 0x82,
+ // Bytes 580 - 5bf
+ 0xB9, 0x43, 0xE3, 0x82, 0xBB, 0x43, 0xE3, 0x82,
+ 0xBD, 0x43, 0xE3, 0x82, 0xBF, 0x43, 0xE3, 0x83,
+ 0x81, 0x43, 0xE3, 0x83, 0x83, 0x43, 0xE3, 0x83,
+ 0x84, 0x43, 0xE3, 0x83, 0x86, 0x43, 0xE3, 0x83,
+ 0x88, 0x43, 0xE3, 0x83, 0x8A, 0x43, 0xE3, 0x83,
+ 0x8B, 0x43, 0xE3, 0x83, 0x8C, 0x43, 0xE3, 0x83,
+ 0x8D, 0x43, 0xE3, 0x83, 0x8E, 0x43, 0xE3, 0x83,
+ 0x8F, 0x43, 0xE3, 0x83, 0x92, 0x43, 0xE3, 0x83,
+ // Bytes 5c0 - 5ff
+ 0x95, 0x43, 0xE3, 0x83, 0x98, 0x43, 0xE3, 0x83,
+ 0x9B, 0x43, 0xE3, 0x83, 0x9E, 0x43, 0xE3, 0x83,
+ 0x9F, 0x43, 0xE3, 0x83, 0xA0, 0x43, 0xE3, 0x83,
+ 0xA1, 0x43, 0xE3, 0x83, 0xA2, 0x43, 0xE3, 0x83,
+ 0xA3, 0x43, 0xE3, 0x83, 0xA4, 0x43, 0xE3, 0x83,
+ 0xA5, 0x43, 0xE3, 0x83, 0xA6, 0x43, 0xE3, 0x83,
+ 0xA7, 0x43, 0xE3, 0x83, 0xA8, 0x43, 0xE3, 0x83,
+ 0xA9, 0x43, 0xE3, 0x83, 0xAA, 0x43, 0xE3, 0x83,
+ // Bytes 600 - 63f
+ 0xAB, 0x43, 0xE3, 0x83, 0xAC, 0x43, 0xE3, 0x83,
+ 0xAD, 0x43, 0xE3, 0x83, 0xAF, 0x43, 0xE3, 0x83,
+ 0xB0, 0x43, 0xE3, 0x83, 0xB1, 0x43, 0xE3, 0x83,
+ 0xB2, 0x43, 0xE3, 0x83, 0xB3, 0x43, 0xE3, 0x83,
+ 0xBB, 0x43, 0xE3, 0x83, 0xBC, 0x43, 0xE3, 0x92,
+ 0x9E, 0x43, 0xE3, 0x92, 0xB9, 0x43, 0xE3, 0x92,
+ 0xBB, 0x43, 0xE3, 0x93, 0x9F, 0x43, 0xE3, 0x94,
+ 0x95, 0x43, 0xE3, 0x9B, 0xAE, 0x43, 0xE3, 0x9B,
+ // Bytes 640 - 67f
+ 0xBC, 0x43, 0xE3, 0x9E, 0x81, 0x43, 0xE3, 0xA0,
+ 0xAF, 0x43, 0xE3, 0xA1, 0xA2, 0x43, 0xE3, 0xA1,
+ 0xBC, 0x43, 0xE3, 0xA3, 0x87, 0x43, 0xE3, 0xA3,
+ 0xA3, 0x43, 0xE3, 0xA4, 0x9C, 0x43, 0xE3, 0xA4,
+ 0xBA, 0x43, 0xE3, 0xA8, 0xAE, 0x43, 0xE3, 0xA9,
+ 0xAC, 0x43, 0xE3, 0xAB, 0xA4, 0x43, 0xE3, 0xAC,
+ 0x88, 0x43, 0xE3, 0xAC, 0x99, 0x43, 0xE3, 0xAD,
+ 0x89, 0x43, 0xE3, 0xAE, 0x9D, 0x43, 0xE3, 0xB0,
+ // Bytes 680 - 6bf
+ 0x98, 0x43, 0xE3, 0xB1, 0x8E, 0x43, 0xE3, 0xB4,
+ 0xB3, 0x43, 0xE3, 0xB6, 0x96, 0x43, 0xE3, 0xBA,
+ 0xAC, 0x43, 0xE3, 0xBA, 0xB8, 0x43, 0xE3, 0xBC,
+ 0x9B, 0x43, 0xE3, 0xBF, 0xBC, 0x43, 0xE4, 0x80,
+ 0x88, 0x43, 0xE4, 0x80, 0x98, 0x43, 0xE4, 0x80,
+ 0xB9, 0x43, 0xE4, 0x81, 0x86, 0x43, 0xE4, 0x82,
+ 0x96, 0x43, 0xE4, 0x83, 0xA3, 0x43, 0xE4, 0x84,
+ 0xAF, 0x43, 0xE4, 0x88, 0x82, 0x43, 0xE4, 0x88,
+ // Bytes 6c0 - 6ff
+ 0xA7, 0x43, 0xE4, 0x8A, 0xA0, 0x43, 0xE4, 0x8C,
+ 0x81, 0x43, 0xE4, 0x8C, 0xB4, 0x43, 0xE4, 0x8D,
+ 0x99, 0x43, 0xE4, 0x8F, 0x95, 0x43, 0xE4, 0x8F,
+ 0x99, 0x43, 0xE4, 0x90, 0x8B, 0x43, 0xE4, 0x91,
+ 0xAB, 0x43, 0xE4, 0x94, 0xAB, 0x43, 0xE4, 0x95,
+ 0x9D, 0x43, 0xE4, 0x95, 0xA1, 0x43, 0xE4, 0x95,
+ 0xAB, 0x43, 0xE4, 0x97, 0x97, 0x43, 0xE4, 0x97,
+ 0xB9, 0x43, 0xE4, 0x98, 0xB5, 0x43, 0xE4, 0x9A,
+ // Bytes 700 - 73f
+ 0xBE, 0x43, 0xE4, 0x9B, 0x87, 0x43, 0xE4, 0xA6,
+ 0x95, 0x43, 0xE4, 0xA7, 0xA6, 0x43, 0xE4, 0xA9,
+ 0xAE, 0x43, 0xE4, 0xA9, 0xB6, 0x43, 0xE4, 0xAA,
+ 0xB2, 0x43, 0xE4, 0xAC, 0xB3, 0x43, 0xE4, 0xAF,
+ 0x8E, 0x43, 0xE4, 0xB3, 0x8E, 0x43, 0xE4, 0xB3,
+ 0xAD, 0x43, 0xE4, 0xB3, 0xB8, 0x43, 0xE4, 0xB5,
+ 0x96, 0x43, 0xE4, 0xB8, 0x80, 0x43, 0xE4, 0xB8,
+ 0x81, 0x43, 0xE4, 0xB8, 0x83, 0x43, 0xE4, 0xB8,
+ // Bytes 740 - 77f
+ 0x89, 0x43, 0xE4, 0xB8, 0x8A, 0x43, 0xE4, 0xB8,
+ 0x8B, 0x43, 0xE4, 0xB8, 0x8D, 0x43, 0xE4, 0xB8,
+ 0x99, 0x43, 0xE4, 0xB8, 0xA6, 0x43, 0xE4, 0xB8,
+ 0xA8, 0x43, 0xE4, 0xB8, 0xAD, 0x43, 0xE4, 0xB8,
+ 0xB2, 0x43, 0xE4, 0xB8, 0xB6, 0x43, 0xE4, 0xB8,
+ 0xB8, 0x43, 0xE4, 0xB8, 0xB9, 0x43, 0xE4, 0xB8,
+ 0xBD, 0x43, 0xE4, 0xB8, 0xBF, 0x43, 0xE4, 0xB9,
+ 0x81, 0x43, 0xE4, 0xB9, 0x99, 0x43, 0xE4, 0xB9,
+ // Bytes 780 - 7bf
+ 0x9D, 0x43, 0xE4, 0xBA, 0x82, 0x43, 0xE4, 0xBA,
+ 0x85, 0x43, 0xE4, 0xBA, 0x86, 0x43, 0xE4, 0xBA,
+ 0x8C, 0x43, 0xE4, 0xBA, 0x94, 0x43, 0xE4, 0xBA,
+ 0xA0, 0x43, 0xE4, 0xBA, 0xA4, 0x43, 0xE4, 0xBA,
+ 0xAE, 0x43, 0xE4, 0xBA, 0xBA, 0x43, 0xE4, 0xBB,
+ 0x80, 0x43, 0xE4, 0xBB, 0x8C, 0x43, 0xE4, 0xBB,
+ 0xA4, 0x43, 0xE4, 0xBC, 0x81, 0x43, 0xE4, 0xBC,
+ 0x91, 0x43, 0xE4, 0xBD, 0xA0, 0x43, 0xE4, 0xBE,
+ // Bytes 7c0 - 7ff
+ 0x80, 0x43, 0xE4, 0xBE, 0x86, 0x43, 0xE4, 0xBE,
+ 0x8B, 0x43, 0xE4, 0xBE, 0xAE, 0x43, 0xE4, 0xBE,
+ 0xBB, 0x43, 0xE4, 0xBE, 0xBF, 0x43, 0xE5, 0x80,
+ 0x82, 0x43, 0xE5, 0x80, 0xAB, 0x43, 0xE5, 0x81,
+ 0xBA, 0x43, 0xE5, 0x82, 0x99, 0x43, 0xE5, 0x83,
+ 0x8F, 0x43, 0xE5, 0x83, 0x9A, 0x43, 0xE5, 0x83,
+ 0xA7, 0x43, 0xE5, 0x84, 0xAA, 0x43, 0xE5, 0x84,
+ 0xBF, 0x43, 0xE5, 0x85, 0x80, 0x43, 0xE5, 0x85,
+ // Bytes 800 - 83f
+ 0x85, 0x43, 0xE5, 0x85, 0x8D, 0x43, 0xE5, 0x85,
+ 0x94, 0x43, 0xE5, 0x85, 0xA4, 0x43, 0xE5, 0x85,
+ 0xA5, 0x43, 0xE5, 0x85, 0xA7, 0x43, 0xE5, 0x85,
+ 0xA8, 0x43, 0xE5, 0x85, 0xA9, 0x43, 0xE5, 0x85,
+ 0xAB, 0x43, 0xE5, 0x85, 0xAD, 0x43, 0xE5, 0x85,
+ 0xB7, 0x43, 0xE5, 0x86, 0x80, 0x43, 0xE5, 0x86,
+ 0x82, 0x43, 0xE5, 0x86, 0x8D, 0x43, 0xE5, 0x86,
+ 0x92, 0x43, 0xE5, 0x86, 0x95, 0x43, 0xE5, 0x86,
+ // Bytes 840 - 87f
+ 0x96, 0x43, 0xE5, 0x86, 0x97, 0x43, 0xE5, 0x86,
+ 0x99, 0x43, 0xE5, 0x86, 0xA4, 0x43, 0xE5, 0x86,
+ 0xAB, 0x43, 0xE5, 0x86, 0xAC, 0x43, 0xE5, 0x86,
+ 0xB5, 0x43, 0xE5, 0x86, 0xB7, 0x43, 0xE5, 0x87,
+ 0x89, 0x43, 0xE5, 0x87, 0x8C, 0x43, 0xE5, 0x87,
+ 0x9C, 0x43, 0xE5, 0x87, 0x9E, 0x43, 0xE5, 0x87,
+ 0xA0, 0x43, 0xE5, 0x87, 0xB5, 0x43, 0xE5, 0x88,
+ 0x80, 0x43, 0xE5, 0x88, 0x83, 0x43, 0xE5, 0x88,
+ // Bytes 880 - 8bf
+ 0x87, 0x43, 0xE5, 0x88, 0x97, 0x43, 0xE5, 0x88,
+ 0x9D, 0x43, 0xE5, 0x88, 0xA9, 0x43, 0xE5, 0x88,
+ 0xBA, 0x43, 0xE5, 0x88, 0xBB, 0x43, 0xE5, 0x89,
+ 0x86, 0x43, 0xE5, 0x89, 0x8D, 0x43, 0xE5, 0x89,
+ 0xB2, 0x43, 0xE5, 0x89, 0xB7, 0x43, 0xE5, 0x8A,
+ 0x89, 0x43, 0xE5, 0x8A, 0x9B, 0x43, 0xE5, 0x8A,
+ 0xA3, 0x43, 0xE5, 0x8A, 0xB3, 0x43, 0xE5, 0x8A,
+ 0xB4, 0x43, 0xE5, 0x8B, 0x87, 0x43, 0xE5, 0x8B,
+ // Bytes 8c0 - 8ff
+ 0x89, 0x43, 0xE5, 0x8B, 0x92, 0x43, 0xE5, 0x8B,
+ 0x9E, 0x43, 0xE5, 0x8B, 0xA4, 0x43, 0xE5, 0x8B,
+ 0xB5, 0x43, 0xE5, 0x8B, 0xB9, 0x43, 0xE5, 0x8B,
+ 0xBA, 0x43, 0xE5, 0x8C, 0x85, 0x43, 0xE5, 0x8C,
+ 0x86, 0x43, 0xE5, 0x8C, 0x95, 0x43, 0xE5, 0x8C,
+ 0x97, 0x43, 0xE5, 0x8C, 0x9A, 0x43, 0xE5, 0x8C,
+ 0xB8, 0x43, 0xE5, 0x8C, 0xBB, 0x43, 0xE5, 0x8C,
+ 0xBF, 0x43, 0xE5, 0x8D, 0x81, 0x43, 0xE5, 0x8D,
+ // Bytes 900 - 93f
+ 0x84, 0x43, 0xE5, 0x8D, 0x85, 0x43, 0xE5, 0x8D,
+ 0x89, 0x43, 0xE5, 0x8D, 0x91, 0x43, 0xE5, 0x8D,
+ 0x94, 0x43, 0xE5, 0x8D, 0x9A, 0x43, 0xE5, 0x8D,
+ 0x9C, 0x43, 0xE5, 0x8D, 0xA9, 0x43, 0xE5, 0x8D,
+ 0xB0, 0x43, 0xE5, 0x8D, 0xB3, 0x43, 0xE5, 0x8D,
+ 0xB5, 0x43, 0xE5, 0x8D, 0xBD, 0x43, 0xE5, 0x8D,
+ 0xBF, 0x43, 0xE5, 0x8E, 0x82, 0x43, 0xE5, 0x8E,
+ 0xB6, 0x43, 0xE5, 0x8F, 0x83, 0x43, 0xE5, 0x8F,
+ // Bytes 940 - 97f
+ 0x88, 0x43, 0xE5, 0x8F, 0x8A, 0x43, 0xE5, 0x8F,
+ 0x8C, 0x43, 0xE5, 0x8F, 0x9F, 0x43, 0xE5, 0x8F,
+ 0xA3, 0x43, 0xE5, 0x8F, 0xA5, 0x43, 0xE5, 0x8F,
+ 0xAB, 0x43, 0xE5, 0x8F, 0xAF, 0x43, 0xE5, 0x8F,
+ 0xB1, 0x43, 0xE5, 0x8F, 0xB3, 0x43, 0xE5, 0x90,
+ 0x86, 0x43, 0xE5, 0x90, 0x88, 0x43, 0xE5, 0x90,
+ 0x8D, 0x43, 0xE5, 0x90, 0x8F, 0x43, 0xE5, 0x90,
+ 0x9D, 0x43, 0xE5, 0x90, 0xB8, 0x43, 0xE5, 0x90,
+ // Bytes 980 - 9bf
+ 0xB9, 0x43, 0xE5, 0x91, 0x82, 0x43, 0xE5, 0x91,
+ 0x88, 0x43, 0xE5, 0x91, 0xA8, 0x43, 0xE5, 0x92,
+ 0x9E, 0x43, 0xE5, 0x92, 0xA2, 0x43, 0xE5, 0x92,
+ 0xBD, 0x43, 0xE5, 0x93, 0xB6, 0x43, 0xE5, 0x94,
+ 0x90, 0x43, 0xE5, 0x95, 0x8F, 0x43, 0xE5, 0x95,
+ 0x93, 0x43, 0xE5, 0x95, 0x95, 0x43, 0xE5, 0x95,
+ 0xA3, 0x43, 0xE5, 0x96, 0x84, 0x43, 0xE5, 0x96,
+ 0x87, 0x43, 0xE5, 0x96, 0x99, 0x43, 0xE5, 0x96,
+ // Bytes 9c0 - 9ff
+ 0x9D, 0x43, 0xE5, 0x96, 0xAB, 0x43, 0xE5, 0x96,
+ 0xB3, 0x43, 0xE5, 0x96, 0xB6, 0x43, 0xE5, 0x97,
+ 0x80, 0x43, 0xE5, 0x97, 0x82, 0x43, 0xE5, 0x97,
+ 0xA2, 0x43, 0xE5, 0x98, 0x86, 0x43, 0xE5, 0x99,
+ 0x91, 0x43, 0xE5, 0x99, 0xA8, 0x43, 0xE5, 0x99,
+ 0xB4, 0x43, 0xE5, 0x9B, 0x97, 0x43, 0xE5, 0x9B,
+ 0x9B, 0x43, 0xE5, 0x9B, 0xB9, 0x43, 0xE5, 0x9C,
+ 0x96, 0x43, 0xE5, 0x9C, 0x97, 0x43, 0xE5, 0x9C,
+ // Bytes a00 - a3f
+ 0x9F, 0x43, 0xE5, 0x9C, 0xB0, 0x43, 0xE5, 0x9E,
+ 0x8B, 0x43, 0xE5, 0x9F, 0x8E, 0x43, 0xE5, 0x9F,
+ 0xB4, 0x43, 0xE5, 0xA0, 0x8D, 0x43, 0xE5, 0xA0,
+ 0xB1, 0x43, 0xE5, 0xA0, 0xB2, 0x43, 0xE5, 0xA1,
+ 0x80, 0x43, 0xE5, 0xA1, 0x9A, 0x43, 0xE5, 0xA1,
+ 0x9E, 0x43, 0xE5, 0xA2, 0xA8, 0x43, 0xE5, 0xA2,
+ 0xAC, 0x43, 0xE5, 0xA2, 0xB3, 0x43, 0xE5, 0xA3,
+ 0x98, 0x43, 0xE5, 0xA3, 0x9F, 0x43, 0xE5, 0xA3,
+ // Bytes a40 - a7f
+ 0xAB, 0x43, 0xE5, 0xA3, 0xAE, 0x43, 0xE5, 0xA3,
+ 0xB0, 0x43, 0xE5, 0xA3, 0xB2, 0x43, 0xE5, 0xA3,
+ 0xB7, 0x43, 0xE5, 0xA4, 0x82, 0x43, 0xE5, 0xA4,
+ 0x86, 0x43, 0xE5, 0xA4, 0x8A, 0x43, 0xE5, 0xA4,
+ 0x95, 0x43, 0xE5, 0xA4, 0x9A, 0x43, 0xE5, 0xA4,
+ 0x9C, 0x43, 0xE5, 0xA4, 0xA2, 0x43, 0xE5, 0xA4,
+ 0xA7, 0x43, 0xE5, 0xA4, 0xA9, 0x43, 0xE5, 0xA5,
+ 0x84, 0x43, 0xE5, 0xA5, 0x88, 0x43, 0xE5, 0xA5,
+ // Bytes a80 - abf
+ 0x91, 0x43, 0xE5, 0xA5, 0x94, 0x43, 0xE5, 0xA5,
+ 0xA2, 0x43, 0xE5, 0xA5, 0xB3, 0x43, 0xE5, 0xA7,
+ 0x98, 0x43, 0xE5, 0xA7, 0xAC, 0x43, 0xE5, 0xA8,
+ 0x9B, 0x43, 0xE5, 0xA8, 0xA7, 0x43, 0xE5, 0xA9,
+ 0xA2, 0x43, 0xE5, 0xA9, 0xA6, 0x43, 0xE5, 0xAA,
+ 0xB5, 0x43, 0xE5, 0xAC, 0x88, 0x43, 0xE5, 0xAC,
+ 0xA8, 0x43, 0xE5, 0xAC, 0xBE, 0x43, 0xE5, 0xAD,
+ 0x90, 0x43, 0xE5, 0xAD, 0x97, 0x43, 0xE5, 0xAD,
+ // Bytes ac0 - aff
+ 0xA6, 0x43, 0xE5, 0xAE, 0x80, 0x43, 0xE5, 0xAE,
+ 0x85, 0x43, 0xE5, 0xAE, 0x97, 0x43, 0xE5, 0xAF,
+ 0x83, 0x43, 0xE5, 0xAF, 0x98, 0x43, 0xE5, 0xAF,
+ 0xA7, 0x43, 0xE5, 0xAF, 0xAE, 0x43, 0xE5, 0xAF,
+ 0xB3, 0x43, 0xE5, 0xAF, 0xB8, 0x43, 0xE5, 0xAF,
+ 0xBF, 0x43, 0xE5, 0xB0, 0x86, 0x43, 0xE5, 0xB0,
+ 0x8F, 0x43, 0xE5, 0xB0, 0xA2, 0x43, 0xE5, 0xB0,
+ 0xB8, 0x43, 0xE5, 0xB0, 0xBF, 0x43, 0xE5, 0xB1,
+ // Bytes b00 - b3f
+ 0xA0, 0x43, 0xE5, 0xB1, 0xA2, 0x43, 0xE5, 0xB1,
+ 0xA4, 0x43, 0xE5, 0xB1, 0xA5, 0x43, 0xE5, 0xB1,
+ 0xAE, 0x43, 0xE5, 0xB1, 0xB1, 0x43, 0xE5, 0xB2,
+ 0x8D, 0x43, 0xE5, 0xB3, 0x80, 0x43, 0xE5, 0xB4,
+ 0x99, 0x43, 0xE5, 0xB5, 0x83, 0x43, 0xE5, 0xB5,
+ 0x90, 0x43, 0xE5, 0xB5, 0xAB, 0x43, 0xE5, 0xB5,
+ 0xAE, 0x43, 0xE5, 0xB5, 0xBC, 0x43, 0xE5, 0xB6,
+ 0xB2, 0x43, 0xE5, 0xB6, 0xBA, 0x43, 0xE5, 0xB7,
+ // Bytes b40 - b7f
+ 0x9B, 0x43, 0xE5, 0xB7, 0xA1, 0x43, 0xE5, 0xB7,
+ 0xA2, 0x43, 0xE5, 0xB7, 0xA5, 0x43, 0xE5, 0xB7,
+ 0xA6, 0x43, 0xE5, 0xB7, 0xB1, 0x43, 0xE5, 0xB7,
+ 0xBD, 0x43, 0xE5, 0xB7, 0xBE, 0x43, 0xE5, 0xB8,
+ 0xA8, 0x43, 0xE5, 0xB8, 0xBD, 0x43, 0xE5, 0xB9,
+ 0xA9, 0x43, 0xE5, 0xB9, 0xB2, 0x43, 0xE5, 0xB9,
+ 0xB4, 0x43, 0xE5, 0xB9, 0xBA, 0x43, 0xE5, 0xB9,
+ 0xBC, 0x43, 0xE5, 0xB9, 0xBF, 0x43, 0xE5, 0xBA,
+ // Bytes b80 - bbf
+ 0xA6, 0x43, 0xE5, 0xBA, 0xB0, 0x43, 0xE5, 0xBA,
+ 0xB3, 0x43, 0xE5, 0xBA, 0xB6, 0x43, 0xE5, 0xBB,
+ 0x89, 0x43, 0xE5, 0xBB, 0x8A, 0x43, 0xE5, 0xBB,
+ 0x92, 0x43, 0xE5, 0xBB, 0x93, 0x43, 0xE5, 0xBB,
+ 0x99, 0x43, 0xE5, 0xBB, 0xAC, 0x43, 0xE5, 0xBB,
+ 0xB4, 0x43, 0xE5, 0xBB, 0xBE, 0x43, 0xE5, 0xBC,
+ 0x84, 0x43, 0xE5, 0xBC, 0x8B, 0x43, 0xE5, 0xBC,
+ 0x93, 0x43, 0xE5, 0xBC, 0xA2, 0x43, 0xE5, 0xBD,
+ // Bytes bc0 - bff
+ 0x90, 0x43, 0xE5, 0xBD, 0x93, 0x43, 0xE5, 0xBD,
+ 0xA1, 0x43, 0xE5, 0xBD, 0xA2, 0x43, 0xE5, 0xBD,
+ 0xA9, 0x43, 0xE5, 0xBD, 0xAB, 0x43, 0xE5, 0xBD,
+ 0xB3, 0x43, 0xE5, 0xBE, 0x8B, 0x43, 0xE5, 0xBE,
+ 0x8C, 0x43, 0xE5, 0xBE, 0x97, 0x43, 0xE5, 0xBE,
+ 0x9A, 0x43, 0xE5, 0xBE, 0xA9, 0x43, 0xE5, 0xBE,
+ 0xAD, 0x43, 0xE5, 0xBF, 0x83, 0x43, 0xE5, 0xBF,
+ 0x8D, 0x43, 0xE5, 0xBF, 0x97, 0x43, 0xE5, 0xBF,
+ // Bytes c00 - c3f
+ 0xB5, 0x43, 0xE5, 0xBF, 0xB9, 0x43, 0xE6, 0x80,
+ 0x92, 0x43, 0xE6, 0x80, 0x9C, 0x43, 0xE6, 0x81,
+ 0xB5, 0x43, 0xE6, 0x82, 0x81, 0x43, 0xE6, 0x82,
+ 0x94, 0x43, 0xE6, 0x83, 0x87, 0x43, 0xE6, 0x83,
+ 0x98, 0x43, 0xE6, 0x83, 0xA1, 0x43, 0xE6, 0x84,
+ 0x88, 0x43, 0xE6, 0x85, 0x84, 0x43, 0xE6, 0x85,
+ 0x88, 0x43, 0xE6, 0x85, 0x8C, 0x43, 0xE6, 0x85,
+ 0x8E, 0x43, 0xE6, 0x85, 0xA0, 0x43, 0xE6, 0x85,
+ // Bytes c40 - c7f
+ 0xA8, 0x43, 0xE6, 0x85, 0xBA, 0x43, 0xE6, 0x86,
+ 0x8E, 0x43, 0xE6, 0x86, 0x90, 0x43, 0xE6, 0x86,
+ 0xA4, 0x43, 0xE6, 0x86, 0xAF, 0x43, 0xE6, 0x86,
+ 0xB2, 0x43, 0xE6, 0x87, 0x9E, 0x43, 0xE6, 0x87,
+ 0xB2, 0x43, 0xE6, 0x87, 0xB6, 0x43, 0xE6, 0x88,
+ 0x80, 0x43, 0xE6, 0x88, 0x88, 0x43, 0xE6, 0x88,
+ 0x90, 0x43, 0xE6, 0x88, 0x9B, 0x43, 0xE6, 0x88,
+ 0xAE, 0x43, 0xE6, 0x88, 0xB4, 0x43, 0xE6, 0x88,
+ // Bytes c80 - cbf
+ 0xB6, 0x43, 0xE6, 0x89, 0x8B, 0x43, 0xE6, 0x89,
+ 0x93, 0x43, 0xE6, 0x89, 0x9D, 0x43, 0xE6, 0x8A,
+ 0x95, 0x43, 0xE6, 0x8A, 0xB1, 0x43, 0xE6, 0x8B,
+ 0x89, 0x43, 0xE6, 0x8B, 0x8F, 0x43, 0xE6, 0x8B,
+ 0x93, 0x43, 0xE6, 0x8B, 0x94, 0x43, 0xE6, 0x8B,
+ 0xBC, 0x43, 0xE6, 0x8B, 0xBE, 0x43, 0xE6, 0x8C,
+ 0x87, 0x43, 0xE6, 0x8C, 0xBD, 0x43, 0xE6, 0x8D,
+ 0x90, 0x43, 0xE6, 0x8D, 0x95, 0x43, 0xE6, 0x8D,
+ // Bytes cc0 - cff
+ 0xA8, 0x43, 0xE6, 0x8D, 0xBB, 0x43, 0xE6, 0x8E,
+ 0x83, 0x43, 0xE6, 0x8E, 0xA0, 0x43, 0xE6, 0x8E,
+ 0xA9, 0x43, 0xE6, 0x8F, 0x84, 0x43, 0xE6, 0x8F,
+ 0x85, 0x43, 0xE6, 0x8F, 0xA4, 0x43, 0xE6, 0x90,
+ 0x9C, 0x43, 0xE6, 0x90, 0xA2, 0x43, 0xE6, 0x91,
+ 0x92, 0x43, 0xE6, 0x91, 0xA9, 0x43, 0xE6, 0x91,
+ 0xB7, 0x43, 0xE6, 0x91, 0xBE, 0x43, 0xE6, 0x92,
+ 0x9A, 0x43, 0xE6, 0x92, 0x9D, 0x43, 0xE6, 0x93,
+ // Bytes d00 - d3f
+ 0x84, 0x43, 0xE6, 0x94, 0xAF, 0x43, 0xE6, 0x94,
+ 0xB4, 0x43, 0xE6, 0x95, 0x8F, 0x43, 0xE6, 0x95,
+ 0x96, 0x43, 0xE6, 0x95, 0xAC, 0x43, 0xE6, 0x95,
+ 0xB8, 0x43, 0xE6, 0x96, 0x87, 0x43, 0xE6, 0x96,
+ 0x97, 0x43, 0xE6, 0x96, 0x99, 0x43, 0xE6, 0x96,
+ 0xA4, 0x43, 0xE6, 0x96, 0xB0, 0x43, 0xE6, 0x96,
+ 0xB9, 0x43, 0xE6, 0x97, 0x85, 0x43, 0xE6, 0x97,
+ 0xA0, 0x43, 0xE6, 0x97, 0xA2, 0x43, 0xE6, 0x97,
+ // Bytes d40 - d7f
+ 0xA3, 0x43, 0xE6, 0x97, 0xA5, 0x43, 0xE6, 0x98,
+ 0x93, 0x43, 0xE6, 0x98, 0xA0, 0x43, 0xE6, 0x99,
+ 0x89, 0x43, 0xE6, 0x99, 0xB4, 0x43, 0xE6, 0x9A,
+ 0x88, 0x43, 0xE6, 0x9A, 0x91, 0x43, 0xE6, 0x9A,
+ 0x9C, 0x43, 0xE6, 0x9A, 0xB4, 0x43, 0xE6, 0x9B,
+ 0x86, 0x43, 0xE6, 0x9B, 0xB0, 0x43, 0xE6, 0x9B,
+ 0xB4, 0x43, 0xE6, 0x9B, 0xB8, 0x43, 0xE6, 0x9C,
+ 0x80, 0x43, 0xE6, 0x9C, 0x88, 0x43, 0xE6, 0x9C,
+ // Bytes d80 - dbf
+ 0x89, 0x43, 0xE6, 0x9C, 0x97, 0x43, 0xE6, 0x9C,
+ 0x9B, 0x43, 0xE6, 0x9C, 0xA1, 0x43, 0xE6, 0x9C,
+ 0xA8, 0x43, 0xE6, 0x9D, 0x8E, 0x43, 0xE6, 0x9D,
+ 0x93, 0x43, 0xE6, 0x9D, 0x96, 0x43, 0xE6, 0x9D,
+ 0x9E, 0x43, 0xE6, 0x9D, 0xBB, 0x43, 0xE6, 0x9E,
+ 0x85, 0x43, 0xE6, 0x9E, 0x97, 0x43, 0xE6, 0x9F,
+ 0xB3, 0x43, 0xE6, 0x9F, 0xBA, 0x43, 0xE6, 0xA0,
+ 0x97, 0x43, 0xE6, 0xA0, 0x9F, 0x43, 0xE6, 0xA0,
+ // Bytes dc0 - dff
+ 0xAA, 0x43, 0xE6, 0xA1, 0x92, 0x43, 0xE6, 0xA2,
+ 0x81, 0x43, 0xE6, 0xA2, 0x85, 0x43, 0xE6, 0xA2,
+ 0x8E, 0x43, 0xE6, 0xA2, 0xA8, 0x43, 0xE6, 0xA4,
+ 0x94, 0x43, 0xE6, 0xA5, 0x82, 0x43, 0xE6, 0xA6,
+ 0xA3, 0x43, 0xE6, 0xA7, 0xAA, 0x43, 0xE6, 0xA8,
+ 0x82, 0x43, 0xE6, 0xA8, 0x93, 0x43, 0xE6, 0xAA,
+ 0xA8, 0x43, 0xE6, 0xAB, 0x93, 0x43, 0xE6, 0xAB,
+ 0x9B, 0x43, 0xE6, 0xAC, 0x84, 0x43, 0xE6, 0xAC,
+ // Bytes e00 - e3f
+ 0xA0, 0x43, 0xE6, 0xAC, 0xA1, 0x43, 0xE6, 0xAD,
+ 0x94, 0x43, 0xE6, 0xAD, 0xA2, 0x43, 0xE6, 0xAD,
+ 0xA3, 0x43, 0xE6, 0xAD, 0xB2, 0x43, 0xE6, 0xAD,
+ 0xB7, 0x43, 0xE6, 0xAD, 0xB9, 0x43, 0xE6, 0xAE,
+ 0x9F, 0x43, 0xE6, 0xAE, 0xAE, 0x43, 0xE6, 0xAE,
+ 0xB3, 0x43, 0xE6, 0xAE, 0xBA, 0x43, 0xE6, 0xAE,
+ 0xBB, 0x43, 0xE6, 0xAF, 0x8B, 0x43, 0xE6, 0xAF,
+ 0x8D, 0x43, 0xE6, 0xAF, 0x94, 0x43, 0xE6, 0xAF,
+ // Bytes e40 - e7f
+ 0x9B, 0x43, 0xE6, 0xB0, 0x8F, 0x43, 0xE6, 0xB0,
+ 0x94, 0x43, 0xE6, 0xB0, 0xB4, 0x43, 0xE6, 0xB1,
+ 0x8E, 0x43, 0xE6, 0xB1, 0xA7, 0x43, 0xE6, 0xB2,
+ 0x88, 0x43, 0xE6, 0xB2, 0xBF, 0x43, 0xE6, 0xB3,
+ 0x8C, 0x43, 0xE6, 0xB3, 0x8D, 0x43, 0xE6, 0xB3,
+ 0xA5, 0x43, 0xE6, 0xB3, 0xA8, 0x43, 0xE6, 0xB4,
+ 0x96, 0x43, 0xE6, 0xB4, 0x9B, 0x43, 0xE6, 0xB4,
+ 0x9E, 0x43, 0xE6, 0xB4, 0xB4, 0x43, 0xE6, 0xB4,
+ // Bytes e80 - ebf
+ 0xBE, 0x43, 0xE6, 0xB5, 0x81, 0x43, 0xE6, 0xB5,
+ 0xA9, 0x43, 0xE6, 0xB5, 0xAA, 0x43, 0xE6, 0xB5,
+ 0xB7, 0x43, 0xE6, 0xB5, 0xB8, 0x43, 0xE6, 0xB6,
+ 0x85, 0x43, 0xE6, 0xB7, 0x8B, 0x43, 0xE6, 0xB7,
+ 0x9A, 0x43, 0xE6, 0xB7, 0xAA, 0x43, 0xE6, 0xB7,
+ 0xB9, 0x43, 0xE6, 0xB8, 0x9A, 0x43, 0xE6, 0xB8,
+ 0xAF, 0x43, 0xE6, 0xB9, 0xAE, 0x43, 0xE6, 0xBA,
+ 0x80, 0x43, 0xE6, 0xBA, 0x9C, 0x43, 0xE6, 0xBA,
+ // Bytes ec0 - eff
+ 0xBA, 0x43, 0xE6, 0xBB, 0x87, 0x43, 0xE6, 0xBB,
+ 0x8B, 0x43, 0xE6, 0xBB, 0x91, 0x43, 0xE6, 0xBB,
+ 0x9B, 0x43, 0xE6, 0xBC, 0x8F, 0x43, 0xE6, 0xBC,
+ 0x94, 0x43, 0xE6, 0xBC, 0xA2, 0x43, 0xE6, 0xBC,
+ 0xA3, 0x43, 0xE6, 0xBD, 0xAE, 0x43, 0xE6, 0xBF,
+ 0x86, 0x43, 0xE6, 0xBF, 0xAB, 0x43, 0xE6, 0xBF,
+ 0xBE, 0x43, 0xE7, 0x80, 0x9B, 0x43, 0xE7, 0x80,
+ 0x9E, 0x43, 0xE7, 0x80, 0xB9, 0x43, 0xE7, 0x81,
+ // Bytes f00 - f3f
+ 0x8A, 0x43, 0xE7, 0x81, 0xAB, 0x43, 0xE7, 0x81,
+ 0xB0, 0x43, 0xE7, 0x81, 0xB7, 0x43, 0xE7, 0x81,
+ 0xBD, 0x43, 0xE7, 0x82, 0x99, 0x43, 0xE7, 0x82,
+ 0xAD, 0x43, 0xE7, 0x83, 0x88, 0x43, 0xE7, 0x83,
+ 0x99, 0x43, 0xE7, 0x84, 0xA1, 0x43, 0xE7, 0x85,
+ 0x85, 0x43, 0xE7, 0x85, 0x89, 0x43, 0xE7, 0x85,
+ 0xAE, 0x43, 0xE7, 0x86, 0x9C, 0x43, 0xE7, 0x87,
+ 0x8E, 0x43, 0xE7, 0x87, 0x90, 0x43, 0xE7, 0x88,
+ // Bytes f40 - f7f
+ 0x90, 0x43, 0xE7, 0x88, 0x9B, 0x43, 0xE7, 0x88,
+ 0xA8, 0x43, 0xE7, 0x88, 0xAA, 0x43, 0xE7, 0x88,
+ 0xAB, 0x43, 0xE7, 0x88, 0xB5, 0x43, 0xE7, 0x88,
+ 0xB6, 0x43, 0xE7, 0x88, 0xBB, 0x43, 0xE7, 0x88,
+ 0xBF, 0x43, 0xE7, 0x89, 0x87, 0x43, 0xE7, 0x89,
+ 0x90, 0x43, 0xE7, 0x89, 0x99, 0x43, 0xE7, 0x89,
+ 0x9B, 0x43, 0xE7, 0x89, 0xA2, 0x43, 0xE7, 0x89,
+ 0xB9, 0x43, 0xE7, 0x8A, 0x80, 0x43, 0xE7, 0x8A,
+ // Bytes f80 - fbf
+ 0x95, 0x43, 0xE7, 0x8A, 0xAC, 0x43, 0xE7, 0x8A,
+ 0xAF, 0x43, 0xE7, 0x8B, 0x80, 0x43, 0xE7, 0x8B,
+ 0xBC, 0x43, 0xE7, 0x8C, 0xAA, 0x43, 0xE7, 0x8D,
+ 0xB5, 0x43, 0xE7, 0x8D, 0xBA, 0x43, 0xE7, 0x8E,
+ 0x84, 0x43, 0xE7, 0x8E, 0x87, 0x43, 0xE7, 0x8E,
+ 0x89, 0x43, 0xE7, 0x8E, 0x8B, 0x43, 0xE7, 0x8E,
+ 0xA5, 0x43, 0xE7, 0x8E, 0xB2, 0x43, 0xE7, 0x8F,
+ 0x9E, 0x43, 0xE7, 0x90, 0x86, 0x43, 0xE7, 0x90,
+ // Bytes fc0 - fff
+ 0x89, 0x43, 0xE7, 0x90, 0xA2, 0x43, 0xE7, 0x91,
+ 0x87, 0x43, 0xE7, 0x91, 0x9C, 0x43, 0xE7, 0x91,
+ 0xA9, 0x43, 0xE7, 0x91, 0xB1, 0x43, 0xE7, 0x92,
+ 0x85, 0x43, 0xE7, 0x92, 0x89, 0x43, 0xE7, 0x92,
+ 0x98, 0x43, 0xE7, 0x93, 0x8A, 0x43, 0xE7, 0x93,
+ 0x9C, 0x43, 0xE7, 0x93, 0xA6, 0x43, 0xE7, 0x94,
+ 0x86, 0x43, 0xE7, 0x94, 0x98, 0x43, 0xE7, 0x94,
+ 0x9F, 0x43, 0xE7, 0x94, 0xA4, 0x43, 0xE7, 0x94,
+ // Bytes 1000 - 103f
+ 0xA8, 0x43, 0xE7, 0x94, 0xB0, 0x43, 0xE7, 0x94,
+ 0xB2, 0x43, 0xE7, 0x94, 0xB3, 0x43, 0xE7, 0x94,
+ 0xB7, 0x43, 0xE7, 0x94, 0xBB, 0x43, 0xE7, 0x94,
+ 0xBE, 0x43, 0xE7, 0x95, 0x99, 0x43, 0xE7, 0x95,
+ 0xA5, 0x43, 0xE7, 0x95, 0xB0, 0x43, 0xE7, 0x96,
+ 0x8B, 0x43, 0xE7, 0x96, 0x92, 0x43, 0xE7, 0x97,
+ 0xA2, 0x43, 0xE7, 0x98, 0x90, 0x43, 0xE7, 0x98,
+ 0x9D, 0x43, 0xE7, 0x98, 0x9F, 0x43, 0xE7, 0x99,
+ // Bytes 1040 - 107f
+ 0x82, 0x43, 0xE7, 0x99, 0xA9, 0x43, 0xE7, 0x99,
+ 0xB6, 0x43, 0xE7, 0x99, 0xBD, 0x43, 0xE7, 0x9A,
+ 0xAE, 0x43, 0xE7, 0x9A, 0xBF, 0x43, 0xE7, 0x9B,
+ 0x8A, 0x43, 0xE7, 0x9B, 0x9B, 0x43, 0xE7, 0x9B,
+ 0xA3, 0x43, 0xE7, 0x9B, 0xA7, 0x43, 0xE7, 0x9B,
+ 0xAE, 0x43, 0xE7, 0x9B, 0xB4, 0x43, 0xE7, 0x9C,
+ 0x81, 0x43, 0xE7, 0x9C, 0x9E, 0x43, 0xE7, 0x9C,
+ 0x9F, 0x43, 0xE7, 0x9D, 0x80, 0x43, 0xE7, 0x9D,
+ // Bytes 1080 - 10bf
+ 0x8A, 0x43, 0xE7, 0x9E, 0x8B, 0x43, 0xE7, 0x9E,
+ 0xA7, 0x43, 0xE7, 0x9F, 0x9B, 0x43, 0xE7, 0x9F,
+ 0xA2, 0x43, 0xE7, 0x9F, 0xB3, 0x43, 0xE7, 0xA1,
+ 0x8E, 0x43, 0xE7, 0xA1, 0xAB, 0x43, 0xE7, 0xA2,
+ 0x8C, 0x43, 0xE7, 0xA2, 0x91, 0x43, 0xE7, 0xA3,
+ 0x8A, 0x43, 0xE7, 0xA3, 0x8C, 0x43, 0xE7, 0xA3,
+ 0xBB, 0x43, 0xE7, 0xA4, 0xAA, 0x43, 0xE7, 0xA4,
+ 0xBA, 0x43, 0xE7, 0xA4, 0xBC, 0x43, 0xE7, 0xA4,
+ // Bytes 10c0 - 10ff
+ 0xBE, 0x43, 0xE7, 0xA5, 0x88, 0x43, 0xE7, 0xA5,
+ 0x89, 0x43, 0xE7, 0xA5, 0x90, 0x43, 0xE7, 0xA5,
+ 0x96, 0x43, 0xE7, 0xA5, 0x9D, 0x43, 0xE7, 0xA5,
+ 0x9E, 0x43, 0xE7, 0xA5, 0xA5, 0x43, 0xE7, 0xA5,
+ 0xBF, 0x43, 0xE7, 0xA6, 0x81, 0x43, 0xE7, 0xA6,
+ 0x8D, 0x43, 0xE7, 0xA6, 0x8E, 0x43, 0xE7, 0xA6,
+ 0x8F, 0x43, 0xE7, 0xA6, 0xAE, 0x43, 0xE7, 0xA6,
+ 0xB8, 0x43, 0xE7, 0xA6, 0xBE, 0x43, 0xE7, 0xA7,
+ // Bytes 1100 - 113f
+ 0x8A, 0x43, 0xE7, 0xA7, 0x98, 0x43, 0xE7, 0xA7,
+ 0xAB, 0x43, 0xE7, 0xA8, 0x9C, 0x43, 0xE7, 0xA9,
+ 0x80, 0x43, 0xE7, 0xA9, 0x8A, 0x43, 0xE7, 0xA9,
+ 0x8F, 0x43, 0xE7, 0xA9, 0xB4, 0x43, 0xE7, 0xA9,
+ 0xBA, 0x43, 0xE7, 0xAA, 0x81, 0x43, 0xE7, 0xAA,
+ 0xB1, 0x43, 0xE7, 0xAB, 0x8B, 0x43, 0xE7, 0xAB,
+ 0xAE, 0x43, 0xE7, 0xAB, 0xB9, 0x43, 0xE7, 0xAC,
+ 0xA0, 0x43, 0xE7, 0xAE, 0x8F, 0x43, 0xE7, 0xAF,
+ // Bytes 1140 - 117f
+ 0x80, 0x43, 0xE7, 0xAF, 0x86, 0x43, 0xE7, 0xAF,
+ 0x89, 0x43, 0xE7, 0xB0, 0xBE, 0x43, 0xE7, 0xB1,
+ 0xA0, 0x43, 0xE7, 0xB1, 0xB3, 0x43, 0xE7, 0xB1,
+ 0xBB, 0x43, 0xE7, 0xB2, 0x92, 0x43, 0xE7, 0xB2,
+ 0xBE, 0x43, 0xE7, 0xB3, 0x92, 0x43, 0xE7, 0xB3,
+ 0x96, 0x43, 0xE7, 0xB3, 0xA3, 0x43, 0xE7, 0xB3,
+ 0xA7, 0x43, 0xE7, 0xB3, 0xA8, 0x43, 0xE7, 0xB3,
+ 0xB8, 0x43, 0xE7, 0xB4, 0x80, 0x43, 0xE7, 0xB4,
+ // Bytes 1180 - 11bf
+ 0x90, 0x43, 0xE7, 0xB4, 0xA2, 0x43, 0xE7, 0xB4,
+ 0xAF, 0x43, 0xE7, 0xB5, 0x82, 0x43, 0xE7, 0xB5,
+ 0x9B, 0x43, 0xE7, 0xB5, 0xA3, 0x43, 0xE7, 0xB6,
+ 0xA0, 0x43, 0xE7, 0xB6, 0xBE, 0x43, 0xE7, 0xB7,
+ 0x87, 0x43, 0xE7, 0xB7, 0xB4, 0x43, 0xE7, 0xB8,
+ 0x82, 0x43, 0xE7, 0xB8, 0x89, 0x43, 0xE7, 0xB8,
+ 0xB7, 0x43, 0xE7, 0xB9, 0x81, 0x43, 0xE7, 0xB9,
+ 0x85, 0x43, 0xE7, 0xBC, 0xB6, 0x43, 0xE7, 0xBC,
+ // Bytes 11c0 - 11ff
+ 0xBE, 0x43, 0xE7, 0xBD, 0x91, 0x43, 0xE7, 0xBD,
+ 0xB2, 0x43, 0xE7, 0xBD, 0xB9, 0x43, 0xE7, 0xBD,
+ 0xBA, 0x43, 0xE7, 0xBE, 0x85, 0x43, 0xE7, 0xBE,
+ 0x8A, 0x43, 0xE7, 0xBE, 0x95, 0x43, 0xE7, 0xBE,
+ 0x9A, 0x43, 0xE7, 0xBE, 0xBD, 0x43, 0xE7, 0xBF,
+ 0xBA, 0x43, 0xE8, 0x80, 0x81, 0x43, 0xE8, 0x80,
+ 0x85, 0x43, 0xE8, 0x80, 0x8C, 0x43, 0xE8, 0x80,
+ 0x92, 0x43, 0xE8, 0x80, 0xB3, 0x43, 0xE8, 0x81,
+ // Bytes 1200 - 123f
+ 0x86, 0x43, 0xE8, 0x81, 0xA0, 0x43, 0xE8, 0x81,
+ 0xAF, 0x43, 0xE8, 0x81, 0xB0, 0x43, 0xE8, 0x81,
+ 0xBE, 0x43, 0xE8, 0x81, 0xBF, 0x43, 0xE8, 0x82,
+ 0x89, 0x43, 0xE8, 0x82, 0x8B, 0x43, 0xE8, 0x82,
+ 0xAD, 0x43, 0xE8, 0x82, 0xB2, 0x43, 0xE8, 0x84,
+ 0x83, 0x43, 0xE8, 0x84, 0xBE, 0x43, 0xE8, 0x87,
+ 0x98, 0x43, 0xE8, 0x87, 0xA3, 0x43, 0xE8, 0x87,
+ 0xA8, 0x43, 0xE8, 0x87, 0xAA, 0x43, 0xE8, 0x87,
+ // Bytes 1240 - 127f
+ 0xAD, 0x43, 0xE8, 0x87, 0xB3, 0x43, 0xE8, 0x87,
+ 0xBC, 0x43, 0xE8, 0x88, 0x81, 0x43, 0xE8, 0x88,
+ 0x84, 0x43, 0xE8, 0x88, 0x8C, 0x43, 0xE8, 0x88,
+ 0x98, 0x43, 0xE8, 0x88, 0x9B, 0x43, 0xE8, 0x88,
+ 0x9F, 0x43, 0xE8, 0x89, 0xAE, 0x43, 0xE8, 0x89,
+ 0xAF, 0x43, 0xE8, 0x89, 0xB2, 0x43, 0xE8, 0x89,
+ 0xB8, 0x43, 0xE8, 0x89, 0xB9, 0x43, 0xE8, 0x8A,
+ 0x8B, 0x43, 0xE8, 0x8A, 0x91, 0x43, 0xE8, 0x8A,
+ // Bytes 1280 - 12bf
+ 0x9D, 0x43, 0xE8, 0x8A, 0xB1, 0x43, 0xE8, 0x8A,
+ 0xB3, 0x43, 0xE8, 0x8A, 0xBD, 0x43, 0xE8, 0x8B,
+ 0xA5, 0x43, 0xE8, 0x8B, 0xA6, 0x43, 0xE8, 0x8C,
+ 0x9D, 0x43, 0xE8, 0x8C, 0xA3, 0x43, 0xE8, 0x8C,
+ 0xB6, 0x43, 0xE8, 0x8D, 0x92, 0x43, 0xE8, 0x8D,
+ 0x93, 0x43, 0xE8, 0x8D, 0xA3, 0x43, 0xE8, 0x8E,
+ 0xAD, 0x43, 0xE8, 0x8E, 0xBD, 0x43, 0xE8, 0x8F,
+ 0x89, 0x43, 0xE8, 0x8F, 0x8A, 0x43, 0xE8, 0x8F,
+ // Bytes 12c0 - 12ff
+ 0x8C, 0x43, 0xE8, 0x8F, 0x9C, 0x43, 0xE8, 0x8F,
+ 0xA7, 0x43, 0xE8, 0x8F, 0xAF, 0x43, 0xE8, 0x8F,
+ 0xB1, 0x43, 0xE8, 0x90, 0xBD, 0x43, 0xE8, 0x91,
+ 0x89, 0x43, 0xE8, 0x91, 0x97, 0x43, 0xE8, 0x93,
+ 0xAE, 0x43, 0xE8, 0x93, 0xB1, 0x43, 0xE8, 0x93,
+ 0xB3, 0x43, 0xE8, 0x93, 0xBC, 0x43, 0xE8, 0x94,
+ 0x96, 0x43, 0xE8, 0x95, 0xA4, 0x43, 0xE8, 0x97,
+ 0x8D, 0x43, 0xE8, 0x97, 0xBA, 0x43, 0xE8, 0x98,
+ // Bytes 1300 - 133f
+ 0x86, 0x43, 0xE8, 0x98, 0x92, 0x43, 0xE8, 0x98,
+ 0xAD, 0x43, 0xE8, 0x98, 0xBF, 0x43, 0xE8, 0x99,
+ 0x8D, 0x43, 0xE8, 0x99, 0x90, 0x43, 0xE8, 0x99,
+ 0x9C, 0x43, 0xE8, 0x99, 0xA7, 0x43, 0xE8, 0x99,
+ 0xA9, 0x43, 0xE8, 0x99, 0xAB, 0x43, 0xE8, 0x9A,
+ 0x88, 0x43, 0xE8, 0x9A, 0xA9, 0x43, 0xE8, 0x9B,
+ 0xA2, 0x43, 0xE8, 0x9C, 0x8E, 0x43, 0xE8, 0x9C,
+ 0xA8, 0x43, 0xE8, 0x9D, 0xAB, 0x43, 0xE8, 0x9D,
+ // Bytes 1340 - 137f
+ 0xB9, 0x43, 0xE8, 0x9E, 0x86, 0x43, 0xE8, 0x9E,
+ 0xBA, 0x43, 0xE8, 0x9F, 0xA1, 0x43, 0xE8, 0xA0,
+ 0x81, 0x43, 0xE8, 0xA0, 0x9F, 0x43, 0xE8, 0xA1,
+ 0x80, 0x43, 0xE8, 0xA1, 0x8C, 0x43, 0xE8, 0xA1,
+ 0xA0, 0x43, 0xE8, 0xA1, 0xA3, 0x43, 0xE8, 0xA3,
+ 0x82, 0x43, 0xE8, 0xA3, 0x8F, 0x43, 0xE8, 0xA3,
+ 0x97, 0x43, 0xE8, 0xA3, 0x9E, 0x43, 0xE8, 0xA3,
+ 0xA1, 0x43, 0xE8, 0xA3, 0xB8, 0x43, 0xE8, 0xA3,
+ // Bytes 1380 - 13bf
+ 0xBA, 0x43, 0xE8, 0xA4, 0x90, 0x43, 0xE8, 0xA5,
+ 0x81, 0x43, 0xE8, 0xA5, 0xA4, 0x43, 0xE8, 0xA5,
+ 0xBE, 0x43, 0xE8, 0xA6, 0x86, 0x43, 0xE8, 0xA6,
+ 0x8B, 0x43, 0xE8, 0xA6, 0x96, 0x43, 0xE8, 0xA7,
+ 0x92, 0x43, 0xE8, 0xA7, 0xA3, 0x43, 0xE8, 0xA8,
+ 0x80, 0x43, 0xE8, 0xAA, 0xA0, 0x43, 0xE8, 0xAA,
+ 0xAA, 0x43, 0xE8, 0xAA, 0xBF, 0x43, 0xE8, 0xAB,
+ 0x8B, 0x43, 0xE8, 0xAB, 0x92, 0x43, 0xE8, 0xAB,
+ // Bytes 13c0 - 13ff
+ 0x96, 0x43, 0xE8, 0xAB, 0xAD, 0x43, 0xE8, 0xAB,
+ 0xB8, 0x43, 0xE8, 0xAB, 0xBE, 0x43, 0xE8, 0xAC,
+ 0x81, 0x43, 0xE8, 0xAC, 0xB9, 0x43, 0xE8, 0xAD,
+ 0x98, 0x43, 0xE8, 0xAE, 0x80, 0x43, 0xE8, 0xAE,
+ 0x8A, 0x43, 0xE8, 0xB0, 0xB7, 0x43, 0xE8, 0xB1,
+ 0x86, 0x43, 0xE8, 0xB1, 0x88, 0x43, 0xE8, 0xB1,
+ 0x95, 0x43, 0xE8, 0xB1, 0xB8, 0x43, 0xE8, 0xB2,
+ 0x9D, 0x43, 0xE8, 0xB2, 0xA1, 0x43, 0xE8, 0xB2,
+ // Bytes 1400 - 143f
+ 0xA9, 0x43, 0xE8, 0xB2, 0xAB, 0x43, 0xE8, 0xB3,
+ 0x81, 0x43, 0xE8, 0xB3, 0x82, 0x43, 0xE8, 0xB3,
+ 0x87, 0x43, 0xE8, 0xB3, 0x88, 0x43, 0xE8, 0xB3,
+ 0x93, 0x43, 0xE8, 0xB4, 0x88, 0x43, 0xE8, 0xB4,
+ 0x9B, 0x43, 0xE8, 0xB5, 0xA4, 0x43, 0xE8, 0xB5,
+ 0xB0, 0x43, 0xE8, 0xB5, 0xB7, 0x43, 0xE8, 0xB6,
+ 0xB3, 0x43, 0xE8, 0xB6, 0xBC, 0x43, 0xE8, 0xB7,
+ 0x8B, 0x43, 0xE8, 0xB7, 0xAF, 0x43, 0xE8, 0xB7,
+ // Bytes 1440 - 147f
+ 0xB0, 0x43, 0xE8, 0xBA, 0xAB, 0x43, 0xE8, 0xBB,
+ 0x8A, 0x43, 0xE8, 0xBB, 0x94, 0x43, 0xE8, 0xBC,
+ 0xA6, 0x43, 0xE8, 0xBC, 0xAA, 0x43, 0xE8, 0xBC,
+ 0xB8, 0x43, 0xE8, 0xBC, 0xBB, 0x43, 0xE8, 0xBD,
+ 0xA2, 0x43, 0xE8, 0xBE, 0x9B, 0x43, 0xE8, 0xBE,
+ 0x9E, 0x43, 0xE8, 0xBE, 0xB0, 0x43, 0xE8, 0xBE,
+ 0xB5, 0x43, 0xE8, 0xBE, 0xB6, 0x43, 0xE9, 0x80,
+ 0xA3, 0x43, 0xE9, 0x80, 0xB8, 0x43, 0xE9, 0x81,
+ // Bytes 1480 - 14bf
+ 0x8A, 0x43, 0xE9, 0x81, 0xA9, 0x43, 0xE9, 0x81,
+ 0xB2, 0x43, 0xE9, 0x81, 0xBC, 0x43, 0xE9, 0x82,
+ 0x8F, 0x43, 0xE9, 0x82, 0x91, 0x43, 0xE9, 0x82,
+ 0x94, 0x43, 0xE9, 0x83, 0x8E, 0x43, 0xE9, 0x83,
+ 0x9E, 0x43, 0xE9, 0x83, 0xB1, 0x43, 0xE9, 0x83,
+ 0xBD, 0x43, 0xE9, 0x84, 0x91, 0x43, 0xE9, 0x84,
+ 0x9B, 0x43, 0xE9, 0x85, 0x89, 0x43, 0xE9, 0x85,
+ 0xAA, 0x43, 0xE9, 0x86, 0x99, 0x43, 0xE9, 0x86,
+ // Bytes 14c0 - 14ff
+ 0xB4, 0x43, 0xE9, 0x87, 0x86, 0x43, 0xE9, 0x87,
+ 0x8C, 0x43, 0xE9, 0x87, 0x8F, 0x43, 0xE9, 0x87,
+ 0x91, 0x43, 0xE9, 0x88, 0xB4, 0x43, 0xE9, 0x88,
+ 0xB8, 0x43, 0xE9, 0x89, 0xB6, 0x43, 0xE9, 0x89,
+ 0xBC, 0x43, 0xE9, 0x8B, 0x97, 0x43, 0xE9, 0x8B,
+ 0x98, 0x43, 0xE9, 0x8C, 0x84, 0x43, 0xE9, 0x8D,
+ 0x8A, 0x43, 0xE9, 0x8F, 0xB9, 0x43, 0xE9, 0x90,
+ 0x95, 0x43, 0xE9, 0x95, 0xB7, 0x43, 0xE9, 0x96,
+ // Bytes 1500 - 153f
+ 0x80, 0x43, 0xE9, 0x96, 0x8B, 0x43, 0xE9, 0x96,
+ 0xAD, 0x43, 0xE9, 0x96, 0xB7, 0x43, 0xE9, 0x98,
+ 0x9C, 0x43, 0xE9, 0x98, 0xAE, 0x43, 0xE9, 0x99,
+ 0x8B, 0x43, 0xE9, 0x99, 0x8D, 0x43, 0xE9, 0x99,
+ 0xB5, 0x43, 0xE9, 0x99, 0xB8, 0x43, 0xE9, 0x99,
+ 0xBC, 0x43, 0xE9, 0x9A, 0x86, 0x43, 0xE9, 0x9A,
+ 0xA3, 0x43, 0xE9, 0x9A, 0xB6, 0x43, 0xE9, 0x9A,
+ 0xB7, 0x43, 0xE9, 0x9A, 0xB8, 0x43, 0xE9, 0x9A,
+ // Bytes 1540 - 157f
+ 0xB9, 0x43, 0xE9, 0x9B, 0x83, 0x43, 0xE9, 0x9B,
+ 0xA2, 0x43, 0xE9, 0x9B, 0xA3, 0x43, 0xE9, 0x9B,
+ 0xA8, 0x43, 0xE9, 0x9B, 0xB6, 0x43, 0xE9, 0x9B,
+ 0xB7, 0x43, 0xE9, 0x9C, 0xA3, 0x43, 0xE9, 0x9C,
+ 0xB2, 0x43, 0xE9, 0x9D, 0x88, 0x43, 0xE9, 0x9D,
+ 0x91, 0x43, 0xE9, 0x9D, 0x96, 0x43, 0xE9, 0x9D,
+ 0x9E, 0x43, 0xE9, 0x9D, 0xA2, 0x43, 0xE9, 0x9D,
+ 0xA9, 0x43, 0xE9, 0x9F, 0x8B, 0x43, 0xE9, 0x9F,
+ // Bytes 1580 - 15bf
+ 0x9B, 0x43, 0xE9, 0x9F, 0xA0, 0x43, 0xE9, 0x9F,
+ 0xAD, 0x43, 0xE9, 0x9F, 0xB3, 0x43, 0xE9, 0x9F,
+ 0xBF, 0x43, 0xE9, 0xA0, 0x81, 0x43, 0xE9, 0xA0,
+ 0x85, 0x43, 0xE9, 0xA0, 0x8B, 0x43, 0xE9, 0xA0,
+ 0x98, 0x43, 0xE9, 0xA0, 0xA9, 0x43, 0xE9, 0xA0,
+ 0xBB, 0x43, 0xE9, 0xA1, 0x9E, 0x43, 0xE9, 0xA2,
+ 0xA8, 0x43, 0xE9, 0xA3, 0x9B, 0x43, 0xE9, 0xA3,
+ 0x9F, 0x43, 0xE9, 0xA3, 0xA2, 0x43, 0xE9, 0xA3,
+ // Bytes 15c0 - 15ff
+ 0xAF, 0x43, 0xE9, 0xA3, 0xBC, 0x43, 0xE9, 0xA4,
+ 0xA8, 0x43, 0xE9, 0xA4, 0xA9, 0x43, 0xE9, 0xA6,
+ 0x96, 0x43, 0xE9, 0xA6, 0x99, 0x43, 0xE9, 0xA6,
+ 0xA7, 0x43, 0xE9, 0xA6, 0xAC, 0x43, 0xE9, 0xA7,
+ 0x82, 0x43, 0xE9, 0xA7, 0xB1, 0x43, 0xE9, 0xA7,
+ 0xBE, 0x43, 0xE9, 0xA9, 0xAA, 0x43, 0xE9, 0xAA,
+ 0xA8, 0x43, 0xE9, 0xAB, 0x98, 0x43, 0xE9, 0xAB,
+ 0x9F, 0x43, 0xE9, 0xAC, 0x92, 0x43, 0xE9, 0xAC,
+ // Bytes 1600 - 163f
+ 0xA5, 0x43, 0xE9, 0xAC, 0xAF, 0x43, 0xE9, 0xAC,
+ 0xB2, 0x43, 0xE9, 0xAC, 0xBC, 0x43, 0xE9, 0xAD,
+ 0x9A, 0x43, 0xE9, 0xAD, 0xAF, 0x43, 0xE9, 0xB1,
+ 0x80, 0x43, 0xE9, 0xB1, 0x97, 0x43, 0xE9, 0xB3,
+ 0xA5, 0x43, 0xE9, 0xB3, 0xBD, 0x43, 0xE9, 0xB5,
+ 0xA7, 0x43, 0xE9, 0xB6, 0xB4, 0x43, 0xE9, 0xB7,
+ 0xBA, 0x43, 0xE9, 0xB8, 0x9E, 0x43, 0xE9, 0xB9,
+ 0xB5, 0x43, 0xE9, 0xB9, 0xBF, 0x43, 0xE9, 0xBA,
+ // Bytes 1640 - 167f
+ 0x97, 0x43, 0xE9, 0xBA, 0x9F, 0x43, 0xE9, 0xBA,
+ 0xA5, 0x43, 0xE9, 0xBA, 0xBB, 0x43, 0xE9, 0xBB,
+ 0x83, 0x43, 0xE9, 0xBB, 0x8D, 0x43, 0xE9, 0xBB,
+ 0x8E, 0x43, 0xE9, 0xBB, 0x91, 0x43, 0xE9, 0xBB,
+ 0xB9, 0x43, 0xE9, 0xBB, 0xBD, 0x43, 0xE9, 0xBB,
+ 0xBE, 0x43, 0xE9, 0xBC, 0x85, 0x43, 0xE9, 0xBC,
+ 0x8E, 0x43, 0xE9, 0xBC, 0x8F, 0x43, 0xE9, 0xBC,
+ 0x93, 0x43, 0xE9, 0xBC, 0x96, 0x43, 0xE9, 0xBC,
+ // Bytes 1680 - 16bf
+ 0xA0, 0x43, 0xE9, 0xBC, 0xBB, 0x43, 0xE9, 0xBD,
+ 0x83, 0x43, 0xE9, 0xBD, 0x8A, 0x43, 0xE9, 0xBD,
+ 0x92, 0x43, 0xE9, 0xBE, 0x8D, 0x43, 0xE9, 0xBE,
+ 0x8E, 0x43, 0xE9, 0xBE, 0x9C, 0x43, 0xE9, 0xBE,
+ 0x9F, 0x43, 0xE9, 0xBE, 0xA0, 0x43, 0xEA, 0x9D,
+ 0xAF, 0x44, 0xF0, 0xA0, 0x84, 0xA2, 0x44, 0xF0,
+ 0xA0, 0x94, 0x9C, 0x44, 0xF0, 0xA0, 0x94, 0xA5,
+ 0x44, 0xF0, 0xA0, 0x95, 0x8B, 0x44, 0xF0, 0xA0,
+ // Bytes 16c0 - 16ff
+ 0x98, 0xBA, 0x44, 0xF0, 0xA0, 0xA0, 0x84, 0x44,
+ 0xF0, 0xA0, 0xA3, 0x9E, 0x44, 0xF0, 0xA0, 0xA8,
+ 0xAC, 0x44, 0xF0, 0xA0, 0xAD, 0xA3, 0x44, 0xF0,
+ 0xA1, 0x93, 0xA4, 0x44, 0xF0, 0xA1, 0x9A, 0xA8,
+ 0x44, 0xF0, 0xA1, 0x9B, 0xAA, 0x44, 0xF0, 0xA1,
+ 0xA7, 0x88, 0x44, 0xF0, 0xA1, 0xAC, 0x98, 0x44,
+ 0xF0, 0xA1, 0xB4, 0x8B, 0x44, 0xF0, 0xA1, 0xB7,
+ 0xA4, 0x44, 0xF0, 0xA1, 0xB7, 0xA6, 0x44, 0xF0,
+ // Bytes 1700 - 173f
+ 0xA2, 0x86, 0x83, 0x44, 0xF0, 0xA2, 0x86, 0x9F,
+ 0x44, 0xF0, 0xA2, 0x8C, 0xB1, 0x44, 0xF0, 0xA2,
+ 0x9B, 0x94, 0x44, 0xF0, 0xA2, 0xA1, 0x84, 0x44,
+ 0xF0, 0xA2, 0xA1, 0x8A, 0x44, 0xF0, 0xA2, 0xAC,
+ 0x8C, 0x44, 0xF0, 0xA2, 0xAF, 0xB1, 0x44, 0xF0,
+ 0xA3, 0x80, 0x8A, 0x44, 0xF0, 0xA3, 0x8A, 0xB8,
+ 0x44, 0xF0, 0xA3, 0x8D, 0x9F, 0x44, 0xF0, 0xA3,
+ 0x8E, 0x93, 0x44, 0xF0, 0xA3, 0x8E, 0x9C, 0x44,
+ // Bytes 1740 - 177f
+ 0xF0, 0xA3, 0x8F, 0x83, 0x44, 0xF0, 0xA3, 0x8F,
+ 0x95, 0x44, 0xF0, 0xA3, 0x91, 0xAD, 0x44, 0xF0,
+ 0xA3, 0x9A, 0xA3, 0x44, 0xF0, 0xA3, 0xA2, 0xA7,
+ 0x44, 0xF0, 0xA3, 0xAA, 0x8D, 0x44, 0xF0, 0xA3,
+ 0xAB, 0xBA, 0x44, 0xF0, 0xA3, 0xB2, 0xBC, 0x44,
+ 0xF0, 0xA3, 0xB4, 0x9E, 0x44, 0xF0, 0xA3, 0xBB,
+ 0x91, 0x44, 0xF0, 0xA3, 0xBD, 0x9E, 0x44, 0xF0,
+ 0xA3, 0xBE, 0x8E, 0x44, 0xF0, 0xA4, 0x89, 0xA3,
+ // Bytes 1780 - 17bf
+ 0x44, 0xF0, 0xA4, 0x8B, 0xAE, 0x44, 0xF0, 0xA4,
+ 0x8E, 0xAB, 0x44, 0xF0, 0xA4, 0x98, 0x88, 0x44,
+ 0xF0, 0xA4, 0x9C, 0xB5, 0x44, 0xF0, 0xA4, 0xA0,
+ 0x94, 0x44, 0xF0, 0xA4, 0xB0, 0xB6, 0x44, 0xF0,
+ 0xA4, 0xB2, 0x92, 0x44, 0xF0, 0xA4, 0xBE, 0xA1,
+ 0x44, 0xF0, 0xA4, 0xBE, 0xB8, 0x44, 0xF0, 0xA5,
+ 0x81, 0x84, 0x44, 0xF0, 0xA5, 0x83, 0xB2, 0x44,
+ 0xF0, 0xA5, 0x83, 0xB3, 0x44, 0xF0, 0xA5, 0x84,
+ // Bytes 17c0 - 17ff
+ 0x99, 0x44, 0xF0, 0xA5, 0x84, 0xB3, 0x44, 0xF0,
+ 0xA5, 0x89, 0x89, 0x44, 0xF0, 0xA5, 0x90, 0x9D,
+ 0x44, 0xF0, 0xA5, 0x98, 0xA6, 0x44, 0xF0, 0xA5,
+ 0x9A, 0x9A, 0x44, 0xF0, 0xA5, 0x9B, 0x85, 0x44,
+ 0xF0, 0xA5, 0xA5, 0xBC, 0x44, 0xF0, 0xA5, 0xAA,
+ 0xA7, 0x44, 0xF0, 0xA5, 0xAE, 0xAB, 0x44, 0xF0,
+ 0xA5, 0xB2, 0x80, 0x44, 0xF0, 0xA5, 0xB3, 0x90,
+ 0x44, 0xF0, 0xA5, 0xBE, 0x86, 0x44, 0xF0, 0xA6,
+ // Bytes 1800 - 183f
+ 0x87, 0x9A, 0x44, 0xF0, 0xA6, 0x88, 0xA8, 0x44,
+ 0xF0, 0xA6, 0x89, 0x87, 0x44, 0xF0, 0xA6, 0x8B,
+ 0x99, 0x44, 0xF0, 0xA6, 0x8C, 0xBE, 0x44, 0xF0,
+ 0xA6, 0x93, 0x9A, 0x44, 0xF0, 0xA6, 0x94, 0xA3,
+ 0x44, 0xF0, 0xA6, 0x96, 0xA8, 0x44, 0xF0, 0xA6,
+ 0x9E, 0xA7, 0x44, 0xF0, 0xA6, 0x9E, 0xB5, 0x44,
+ 0xF0, 0xA6, 0xAC, 0xBC, 0x44, 0xF0, 0xA6, 0xB0,
+ 0xB6, 0x44, 0xF0, 0xA6, 0xB3, 0x95, 0x44, 0xF0,
+ // Bytes 1840 - 187f
+ 0xA6, 0xB5, 0xAB, 0x44, 0xF0, 0xA6, 0xBC, 0xAC,
+ 0x44, 0xF0, 0xA6, 0xBE, 0xB1, 0x44, 0xF0, 0xA7,
+ 0x83, 0x92, 0x44, 0xF0, 0xA7, 0x8F, 0x8A, 0x44,
+ 0xF0, 0xA7, 0x99, 0xA7, 0x44, 0xF0, 0xA7, 0xA2,
+ 0xAE, 0x44, 0xF0, 0xA7, 0xA5, 0xA6, 0x44, 0xF0,
+ 0xA7, 0xB2, 0xA8, 0x44, 0xF0, 0xA7, 0xBB, 0x93,
+ 0x44, 0xF0, 0xA7, 0xBC, 0xAF, 0x44, 0xF0, 0xA8,
+ 0x97, 0x92, 0x44, 0xF0, 0xA8, 0x97, 0xAD, 0x44,
+ // Bytes 1880 - 18bf
+ 0xF0, 0xA8, 0x9C, 0xAE, 0x44, 0xF0, 0xA8, 0xAF,
+ 0xBA, 0x44, 0xF0, 0xA8, 0xB5, 0xB7, 0x44, 0xF0,
+ 0xA9, 0x85, 0x85, 0x44, 0xF0, 0xA9, 0x87, 0x9F,
+ 0x44, 0xF0, 0xA9, 0x88, 0x9A, 0x44, 0xF0, 0xA9,
+ 0x90, 0x8A, 0x44, 0xF0, 0xA9, 0x92, 0x96, 0x44,
+ 0xF0, 0xA9, 0x96, 0xB6, 0x44, 0xF0, 0xA9, 0xAC,
+ 0xB0, 0x44, 0xF0, 0xAA, 0x83, 0x8E, 0x44, 0xF0,
+ 0xAA, 0x84, 0x85, 0x44, 0xF0, 0xAA, 0x88, 0x8E,
+ // Bytes 18c0 - 18ff
+ 0x44, 0xF0, 0xAA, 0x8A, 0x91, 0x44, 0xF0, 0xAA,
+ 0x8E, 0x92, 0x44, 0xF0, 0xAA, 0x98, 0x80, 0x06,
+ 0xE0, 0xA7, 0x87, 0xE0, 0xA6, 0xBE, 0x06, 0xE0,
+ 0xA7, 0x87, 0xE0, 0xA7, 0x97, 0x06, 0xE0, 0xAD,
+ 0x87, 0xE0, 0xAC, 0xBE, 0x06, 0xE0, 0xAD, 0x87,
+ 0xE0, 0xAD, 0x96, 0x06, 0xE0, 0xAD, 0x87, 0xE0,
+ 0xAD, 0x97, 0x06, 0xE0, 0xAE, 0x92, 0xE0, 0xAF,
+ 0x97, 0x06, 0xE0, 0xAF, 0x86, 0xE0, 0xAE, 0xBE,
+ // Bytes 1900 - 193f
+ 0x06, 0xE0, 0xAF, 0x86, 0xE0, 0xAF, 0x97, 0x06,
+ 0xE0, 0xAF, 0x87, 0xE0, 0xAE, 0xBE, 0x06, 0xE0,
+ 0xB2, 0xBF, 0xE0, 0xB3, 0x95, 0x06, 0xE0, 0xB3,
+ 0x86, 0xE0, 0xB3, 0x95, 0x06, 0xE0, 0xB3, 0x86,
+ 0xE0, 0xB3, 0x96, 0x06, 0xE0, 0xB5, 0x86, 0xE0,
+ 0xB4, 0xBE, 0x06, 0xE0, 0xB5, 0x86, 0xE0, 0xB5,
+ 0x97, 0x06, 0xE0, 0xB5, 0x87, 0xE0, 0xB4, 0xBE,
+ 0x06, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x9F, 0x06,
+ // Bytes 1940 - 197f
+ 0xE1, 0x80, 0xA5, 0xE1, 0x80, 0xAE, 0x06, 0xE1,
+ 0xAC, 0x85, 0xE1, 0xAC, 0xB5, 0x06, 0xE1, 0xAC,
+ 0x87, 0xE1, 0xAC, 0xB5, 0x06, 0xE1, 0xAC, 0x89,
+ 0xE1, 0xAC, 0xB5, 0x06, 0xE1, 0xAC, 0x8B, 0xE1,
+ 0xAC, 0xB5, 0x06, 0xE1, 0xAC, 0x8D, 0xE1, 0xAC,
+ 0xB5, 0x06, 0xE1, 0xAC, 0x91, 0xE1, 0xAC, 0xB5,
+ 0x06, 0xE1, 0xAC, 0xBA, 0xE1, 0xAC, 0xB5, 0x06,
+ 0xE1, 0xAC, 0xBC, 0xE1, 0xAC, 0xB5, 0x06, 0xE1,
+ // Bytes 1980 - 19bf
+ 0xAC, 0xBE, 0xE1, 0xAC, 0xB5, 0x06, 0xE1, 0xAC,
+ 0xBF, 0xE1, 0xAC, 0xB5, 0x06, 0xE1, 0xAD, 0x82,
+ 0xE1, 0xAC, 0xB5, 0x08, 0xF0, 0x91, 0x84, 0xB1,
+ 0xF0, 0x91, 0x84, 0xA7, 0x08, 0xF0, 0x91, 0x84,
+ 0xB2, 0xF0, 0x91, 0x84, 0xA7, 0x09, 0xE0, 0xB3,
+ 0x86, 0xE0, 0xB3, 0x82, 0xE0, 0xB3, 0x95, 0x42,
+ 0x21, 0x21, 0x42, 0x21, 0x3F, 0x42, 0x2E, 0x2E,
+ 0x42, 0x30, 0x2C, 0x42, 0x30, 0x2E, 0x42, 0x31,
+ // Bytes 19c0 - 19ff
+ 0x2C, 0x42, 0x31, 0x2E, 0x42, 0x31, 0x30, 0x42,
+ 0x31, 0x31, 0x42, 0x31, 0x32, 0x42, 0x31, 0x33,
+ 0x42, 0x31, 0x34, 0x42, 0x31, 0x35, 0x42, 0x31,
+ 0x36, 0x42, 0x31, 0x37, 0x42, 0x31, 0x38, 0x42,
+ 0x31, 0x39, 0x42, 0x32, 0x2C, 0x42, 0x32, 0x2E,
+ 0x42, 0x32, 0x30, 0x42, 0x32, 0x31, 0x42, 0x32,
+ 0x32, 0x42, 0x32, 0x33, 0x42, 0x32, 0x34, 0x42,
+ 0x32, 0x35, 0x42, 0x32, 0x36, 0x42, 0x32, 0x37,
+ // Bytes 1a00 - 1a3f
+ 0x42, 0x32, 0x38, 0x42, 0x32, 0x39, 0x42, 0x33,
+ 0x2C, 0x42, 0x33, 0x2E, 0x42, 0x33, 0x30, 0x42,
+ 0x33, 0x31, 0x42, 0x33, 0x32, 0x42, 0x33, 0x33,
+ 0x42, 0x33, 0x34, 0x42, 0x33, 0x35, 0x42, 0x33,
+ 0x36, 0x42, 0x33, 0x37, 0x42, 0x33, 0x38, 0x42,
+ 0x33, 0x39, 0x42, 0x34, 0x2C, 0x42, 0x34, 0x2E,
+ 0x42, 0x34, 0x30, 0x42, 0x34, 0x31, 0x42, 0x34,
+ 0x32, 0x42, 0x34, 0x33, 0x42, 0x34, 0x34, 0x42,
+ // Bytes 1a40 - 1a7f
+ 0x34, 0x35, 0x42, 0x34, 0x36, 0x42, 0x34, 0x37,
+ 0x42, 0x34, 0x38, 0x42, 0x34, 0x39, 0x42, 0x35,
+ 0x2C, 0x42, 0x35, 0x2E, 0x42, 0x35, 0x30, 0x42,
+ 0x36, 0x2C, 0x42, 0x36, 0x2E, 0x42, 0x37, 0x2C,
+ 0x42, 0x37, 0x2E, 0x42, 0x38, 0x2C, 0x42, 0x38,
+ 0x2E, 0x42, 0x39, 0x2C, 0x42, 0x39, 0x2E, 0x42,
+ 0x3D, 0x3D, 0x42, 0x3F, 0x21, 0x42, 0x3F, 0x3F,
+ 0x42, 0x41, 0x55, 0x42, 0x42, 0x71, 0x42, 0x43,
+ // Bytes 1a80 - 1abf
+ 0x44, 0x42, 0x44, 0x4A, 0x42, 0x44, 0x5A, 0x42,
+ 0x44, 0x7A, 0x42, 0x47, 0x42, 0x42, 0x47, 0x79,
+ 0x42, 0x48, 0x50, 0x42, 0x48, 0x56, 0x42, 0x48,
+ 0x67, 0x42, 0x48, 0x7A, 0x42, 0x49, 0x49, 0x42,
+ 0x49, 0x4A, 0x42, 0x49, 0x55, 0x42, 0x49, 0x56,
+ 0x42, 0x49, 0x58, 0x42, 0x4B, 0x42, 0x42, 0x4B,
+ 0x4B, 0x42, 0x4B, 0x4D, 0x42, 0x4C, 0x4A, 0x42,
+ 0x4C, 0x6A, 0x42, 0x4D, 0x42, 0x42, 0x4D, 0x43,
+ // Bytes 1ac0 - 1aff
+ 0x42, 0x4D, 0x44, 0x42, 0x4D, 0x56, 0x42, 0x4D,
+ 0x57, 0x42, 0x4E, 0x4A, 0x42, 0x4E, 0x6A, 0x42,
+ 0x4E, 0x6F, 0x42, 0x50, 0x48, 0x42, 0x50, 0x52,
+ 0x42, 0x50, 0x61, 0x42, 0x52, 0x73, 0x42, 0x53,
+ 0x44, 0x42, 0x53, 0x4D, 0x42, 0x53, 0x53, 0x42,
+ 0x53, 0x76, 0x42, 0x54, 0x4D, 0x42, 0x56, 0x49,
+ 0x42, 0x57, 0x43, 0x42, 0x57, 0x5A, 0x42, 0x57,
+ 0x62, 0x42, 0x58, 0x49, 0x42, 0x63, 0x63, 0x42,
+ // Bytes 1b00 - 1b3f
+ 0x63, 0x64, 0x42, 0x63, 0x6D, 0x42, 0x64, 0x42,
+ 0x42, 0x64, 0x61, 0x42, 0x64, 0x6C, 0x42, 0x64,
+ 0x6D, 0x42, 0x64, 0x7A, 0x42, 0x65, 0x56, 0x42,
+ 0x66, 0x66, 0x42, 0x66, 0x69, 0x42, 0x66, 0x6C,
+ 0x42, 0x66, 0x6D, 0x42, 0x68, 0x61, 0x42, 0x69,
+ 0x69, 0x42, 0x69, 0x6A, 0x42, 0x69, 0x6E, 0x42,
+ 0x69, 0x76, 0x42, 0x69, 0x78, 0x42, 0x6B, 0x41,
+ 0x42, 0x6B, 0x56, 0x42, 0x6B, 0x57, 0x42, 0x6B,
+ // Bytes 1b40 - 1b7f
+ 0x67, 0x42, 0x6B, 0x6C, 0x42, 0x6B, 0x6D, 0x42,
+ 0x6B, 0x74, 0x42, 0x6C, 0x6A, 0x42, 0x6C, 0x6D,
+ 0x42, 0x6C, 0x6E, 0x42, 0x6C, 0x78, 0x42, 0x6D,
+ 0x32, 0x42, 0x6D, 0x33, 0x42, 0x6D, 0x41, 0x42,
+ 0x6D, 0x56, 0x42, 0x6D, 0x57, 0x42, 0x6D, 0x62,
+ 0x42, 0x6D, 0x67, 0x42, 0x6D, 0x6C, 0x42, 0x6D,
+ 0x6D, 0x42, 0x6D, 0x73, 0x42, 0x6E, 0x41, 0x42,
+ 0x6E, 0x46, 0x42, 0x6E, 0x56, 0x42, 0x6E, 0x57,
+ // Bytes 1b80 - 1bbf
+ 0x42, 0x6E, 0x6A, 0x42, 0x6E, 0x6D, 0x42, 0x6E,
+ 0x73, 0x42, 0x6F, 0x56, 0x42, 0x70, 0x41, 0x42,
+ 0x70, 0x46, 0x42, 0x70, 0x56, 0x42, 0x70, 0x57,
+ 0x42, 0x70, 0x63, 0x42, 0x70, 0x73, 0x42, 0x73,
+ 0x72, 0x42, 0x73, 0x74, 0x42, 0x76, 0x69, 0x42,
+ 0x78, 0x69, 0x43, 0x28, 0x31, 0x29, 0x43, 0x28,
+ 0x32, 0x29, 0x43, 0x28, 0x33, 0x29, 0x43, 0x28,
+ 0x34, 0x29, 0x43, 0x28, 0x35, 0x29, 0x43, 0x28,
+ // Bytes 1bc0 - 1bff
+ 0x36, 0x29, 0x43, 0x28, 0x37, 0x29, 0x43, 0x28,
+ 0x38, 0x29, 0x43, 0x28, 0x39, 0x29, 0x43, 0x28,
+ 0x41, 0x29, 0x43, 0x28, 0x42, 0x29, 0x43, 0x28,
+ 0x43, 0x29, 0x43, 0x28, 0x44, 0x29, 0x43, 0x28,
+ 0x45, 0x29, 0x43, 0x28, 0x46, 0x29, 0x43, 0x28,
+ 0x47, 0x29, 0x43, 0x28, 0x48, 0x29, 0x43, 0x28,
+ 0x49, 0x29, 0x43, 0x28, 0x4A, 0x29, 0x43, 0x28,
+ 0x4B, 0x29, 0x43, 0x28, 0x4C, 0x29, 0x43, 0x28,
+ // Bytes 1c00 - 1c3f
+ 0x4D, 0x29, 0x43, 0x28, 0x4E, 0x29, 0x43, 0x28,
+ 0x4F, 0x29, 0x43, 0x28, 0x50, 0x29, 0x43, 0x28,
+ 0x51, 0x29, 0x43, 0x28, 0x52, 0x29, 0x43, 0x28,
+ 0x53, 0x29, 0x43, 0x28, 0x54, 0x29, 0x43, 0x28,
+ 0x55, 0x29, 0x43, 0x28, 0x56, 0x29, 0x43, 0x28,
+ 0x57, 0x29, 0x43, 0x28, 0x58, 0x29, 0x43, 0x28,
+ 0x59, 0x29, 0x43, 0x28, 0x5A, 0x29, 0x43, 0x28,
+ 0x61, 0x29, 0x43, 0x28, 0x62, 0x29, 0x43, 0x28,
+ // Bytes 1c40 - 1c7f
+ 0x63, 0x29, 0x43, 0x28, 0x64, 0x29, 0x43, 0x28,
+ 0x65, 0x29, 0x43, 0x28, 0x66, 0x29, 0x43, 0x28,
+ 0x67, 0x29, 0x43, 0x28, 0x68, 0x29, 0x43, 0x28,
+ 0x69, 0x29, 0x43, 0x28, 0x6A, 0x29, 0x43, 0x28,
+ 0x6B, 0x29, 0x43, 0x28, 0x6C, 0x29, 0x43, 0x28,
+ 0x6D, 0x29, 0x43, 0x28, 0x6E, 0x29, 0x43, 0x28,
+ 0x6F, 0x29, 0x43, 0x28, 0x70, 0x29, 0x43, 0x28,
+ 0x71, 0x29, 0x43, 0x28, 0x72, 0x29, 0x43, 0x28,
+ // Bytes 1c80 - 1cbf
+ 0x73, 0x29, 0x43, 0x28, 0x74, 0x29, 0x43, 0x28,
+ 0x75, 0x29, 0x43, 0x28, 0x76, 0x29, 0x43, 0x28,
+ 0x77, 0x29, 0x43, 0x28, 0x78, 0x29, 0x43, 0x28,
+ 0x79, 0x29, 0x43, 0x28, 0x7A, 0x29, 0x43, 0x2E,
+ 0x2E, 0x2E, 0x43, 0x31, 0x30, 0x2E, 0x43, 0x31,
+ 0x31, 0x2E, 0x43, 0x31, 0x32, 0x2E, 0x43, 0x31,
+ 0x33, 0x2E, 0x43, 0x31, 0x34, 0x2E, 0x43, 0x31,
+ 0x35, 0x2E, 0x43, 0x31, 0x36, 0x2E, 0x43, 0x31,
+ // Bytes 1cc0 - 1cff
+ 0x37, 0x2E, 0x43, 0x31, 0x38, 0x2E, 0x43, 0x31,
+ 0x39, 0x2E, 0x43, 0x32, 0x30, 0x2E, 0x43, 0x3A,
+ 0x3A, 0x3D, 0x43, 0x3D, 0x3D, 0x3D, 0x43, 0x43,
+ 0x6F, 0x2E, 0x43, 0x46, 0x41, 0x58, 0x43, 0x47,
+ 0x48, 0x7A, 0x43, 0x47, 0x50, 0x61, 0x43, 0x49,
+ 0x49, 0x49, 0x43, 0x4C, 0x54, 0x44, 0x43, 0x4C,
+ 0xC2, 0xB7, 0x43, 0x4D, 0x48, 0x7A, 0x43, 0x4D,
+ 0x50, 0x61, 0x43, 0x4D, 0xCE, 0xA9, 0x43, 0x50,
+ // Bytes 1d00 - 1d3f
+ 0x50, 0x4D, 0x43, 0x50, 0x50, 0x56, 0x43, 0x50,
+ 0x54, 0x45, 0x43, 0x54, 0x45, 0x4C, 0x43, 0x54,
+ 0x48, 0x7A, 0x43, 0x56, 0x49, 0x49, 0x43, 0x58,
+ 0x49, 0x49, 0x43, 0x61, 0x2F, 0x63, 0x43, 0x61,
+ 0x2F, 0x73, 0x43, 0x61, 0xCA, 0xBE, 0x43, 0x62,
+ 0x61, 0x72, 0x43, 0x63, 0x2F, 0x6F, 0x43, 0x63,
+ 0x2F, 0x75, 0x43, 0x63, 0x61, 0x6C, 0x43, 0x63,
+ 0x6D, 0x32, 0x43, 0x63, 0x6D, 0x33, 0x43, 0x64,
+ // Bytes 1d40 - 1d7f
+ 0x6D, 0x32, 0x43, 0x64, 0x6D, 0x33, 0x43, 0x65,
+ 0x72, 0x67, 0x43, 0x66, 0x66, 0x69, 0x43, 0x66,
+ 0x66, 0x6C, 0x43, 0x67, 0x61, 0x6C, 0x43, 0x68,
+ 0x50, 0x61, 0x43, 0x69, 0x69, 0x69, 0x43, 0x6B,
+ 0x48, 0x7A, 0x43, 0x6B, 0x50, 0x61, 0x43, 0x6B,
+ 0x6D, 0x32, 0x43, 0x6B, 0x6D, 0x33, 0x43, 0x6B,
+ 0xCE, 0xA9, 0x43, 0x6C, 0x6F, 0x67, 0x43, 0x6C,
+ 0xC2, 0xB7, 0x43, 0x6D, 0x69, 0x6C, 0x43, 0x6D,
+ // Bytes 1d80 - 1dbf
+ 0x6D, 0x32, 0x43, 0x6D, 0x6D, 0x33, 0x43, 0x6D,
+ 0x6F, 0x6C, 0x43, 0x72, 0x61, 0x64, 0x43, 0x76,
+ 0x69, 0x69, 0x43, 0x78, 0x69, 0x69, 0x43, 0xC2,
+ 0xB0, 0x43, 0x43, 0xC2, 0xB0, 0x46, 0x43, 0xCA,
+ 0xBC, 0x6E, 0x43, 0xCE, 0xBC, 0x41, 0x43, 0xCE,
+ 0xBC, 0x46, 0x43, 0xCE, 0xBC, 0x56, 0x43, 0xCE,
+ 0xBC, 0x57, 0x43, 0xCE, 0xBC, 0x67, 0x43, 0xCE,
+ 0xBC, 0x6C, 0x43, 0xCE, 0xBC, 0x6D, 0x43, 0xCE,
+ // Bytes 1dc0 - 1dff
+ 0xBC, 0x73, 0x44, 0x28, 0x31, 0x30, 0x29, 0x44,
+ 0x28, 0x31, 0x31, 0x29, 0x44, 0x28, 0x31, 0x32,
+ 0x29, 0x44, 0x28, 0x31, 0x33, 0x29, 0x44, 0x28,
+ 0x31, 0x34, 0x29, 0x44, 0x28, 0x31, 0x35, 0x29,
+ 0x44, 0x28, 0x31, 0x36, 0x29, 0x44, 0x28, 0x31,
+ 0x37, 0x29, 0x44, 0x28, 0x31, 0x38, 0x29, 0x44,
+ 0x28, 0x31, 0x39, 0x29, 0x44, 0x28, 0x32, 0x30,
+ 0x29, 0x44, 0x30, 0xE7, 0x82, 0xB9, 0x44, 0x31,
+ // Bytes 1e00 - 1e3f
+ 0xE2, 0x81, 0x84, 0x44, 0x31, 0xE6, 0x97, 0xA5,
+ 0x44, 0x31, 0xE6, 0x9C, 0x88, 0x44, 0x31, 0xE7,
+ 0x82, 0xB9, 0x44, 0x32, 0xE6, 0x97, 0xA5, 0x44,
+ 0x32, 0xE6, 0x9C, 0x88, 0x44, 0x32, 0xE7, 0x82,
+ 0xB9, 0x44, 0x33, 0xE6, 0x97, 0xA5, 0x44, 0x33,
+ 0xE6, 0x9C, 0x88, 0x44, 0x33, 0xE7, 0x82, 0xB9,
+ 0x44, 0x34, 0xE6, 0x97, 0xA5, 0x44, 0x34, 0xE6,
+ 0x9C, 0x88, 0x44, 0x34, 0xE7, 0x82, 0xB9, 0x44,
+ // Bytes 1e40 - 1e7f
+ 0x35, 0xE6, 0x97, 0xA5, 0x44, 0x35, 0xE6, 0x9C,
+ 0x88, 0x44, 0x35, 0xE7, 0x82, 0xB9, 0x44, 0x36,
+ 0xE6, 0x97, 0xA5, 0x44, 0x36, 0xE6, 0x9C, 0x88,
+ 0x44, 0x36, 0xE7, 0x82, 0xB9, 0x44, 0x37, 0xE6,
+ 0x97, 0xA5, 0x44, 0x37, 0xE6, 0x9C, 0x88, 0x44,
+ 0x37, 0xE7, 0x82, 0xB9, 0x44, 0x38, 0xE6, 0x97,
+ 0xA5, 0x44, 0x38, 0xE6, 0x9C, 0x88, 0x44, 0x38,
+ 0xE7, 0x82, 0xB9, 0x44, 0x39, 0xE6, 0x97, 0xA5,
+ // Bytes 1e80 - 1ebf
+ 0x44, 0x39, 0xE6, 0x9C, 0x88, 0x44, 0x39, 0xE7,
+ 0x82, 0xB9, 0x44, 0x56, 0x49, 0x49, 0x49, 0x44,
+ 0x61, 0x2E, 0x6D, 0x2E, 0x44, 0x6B, 0x63, 0x61,
+ 0x6C, 0x44, 0x70, 0x2E, 0x6D, 0x2E, 0x44, 0x76,
+ 0x69, 0x69, 0x69, 0x44, 0xD5, 0xA5, 0xD6, 0x82,
+ 0x44, 0xD5, 0xB4, 0xD5, 0xA5, 0x44, 0xD5, 0xB4,
+ 0xD5, 0xAB, 0x44, 0xD5, 0xB4, 0xD5, 0xAD, 0x44,
+ 0xD5, 0xB4, 0xD5, 0xB6, 0x44, 0xD5, 0xBE, 0xD5,
+ // Bytes 1ec0 - 1eff
+ 0xB6, 0x44, 0xD7, 0x90, 0xD7, 0x9C, 0x44, 0xD8,
+ 0xA7, 0xD9, 0xB4, 0x44, 0xD8, 0xA8, 0xD8, 0xAC,
+ 0x44, 0xD8, 0xA8, 0xD8, 0xAD, 0x44, 0xD8, 0xA8,
+ 0xD8, 0xAE, 0x44, 0xD8, 0xA8, 0xD8, 0xB1, 0x44,
+ 0xD8, 0xA8, 0xD8, 0xB2, 0x44, 0xD8, 0xA8, 0xD9,
+ 0x85, 0x44, 0xD8, 0xA8, 0xD9, 0x86, 0x44, 0xD8,
+ 0xA8, 0xD9, 0x87, 0x44, 0xD8, 0xA8, 0xD9, 0x89,
+ 0x44, 0xD8, 0xA8, 0xD9, 0x8A, 0x44, 0xD8, 0xAA,
+ // Bytes 1f00 - 1f3f
+ 0xD8, 0xAC, 0x44, 0xD8, 0xAA, 0xD8, 0xAD, 0x44,
+ 0xD8, 0xAA, 0xD8, 0xAE, 0x44, 0xD8, 0xAA, 0xD8,
+ 0xB1, 0x44, 0xD8, 0xAA, 0xD8, 0xB2, 0x44, 0xD8,
+ 0xAA, 0xD9, 0x85, 0x44, 0xD8, 0xAA, 0xD9, 0x86,
+ 0x44, 0xD8, 0xAA, 0xD9, 0x87, 0x44, 0xD8, 0xAA,
+ 0xD9, 0x89, 0x44, 0xD8, 0xAA, 0xD9, 0x8A, 0x44,
+ 0xD8, 0xAB, 0xD8, 0xAC, 0x44, 0xD8, 0xAB, 0xD8,
+ 0xB1, 0x44, 0xD8, 0xAB, 0xD8, 0xB2, 0x44, 0xD8,
+ // Bytes 1f40 - 1f7f
+ 0xAB, 0xD9, 0x85, 0x44, 0xD8, 0xAB, 0xD9, 0x86,
+ 0x44, 0xD8, 0xAB, 0xD9, 0x87, 0x44, 0xD8, 0xAB,
+ 0xD9, 0x89, 0x44, 0xD8, 0xAB, 0xD9, 0x8A, 0x44,
+ 0xD8, 0xAC, 0xD8, 0xAD, 0x44, 0xD8, 0xAC, 0xD9,
+ 0x85, 0x44, 0xD8, 0xAC, 0xD9, 0x89, 0x44, 0xD8,
+ 0xAC, 0xD9, 0x8A, 0x44, 0xD8, 0xAD, 0xD8, 0xAC,
+ 0x44, 0xD8, 0xAD, 0xD9, 0x85, 0x44, 0xD8, 0xAD,
+ 0xD9, 0x89, 0x44, 0xD8, 0xAD, 0xD9, 0x8A, 0x44,
+ // Bytes 1f80 - 1fbf
+ 0xD8, 0xAE, 0xD8, 0xAC, 0x44, 0xD8, 0xAE, 0xD8,
+ 0xAD, 0x44, 0xD8, 0xAE, 0xD9, 0x85, 0x44, 0xD8,
+ 0xAE, 0xD9, 0x89, 0x44, 0xD8, 0xAE, 0xD9, 0x8A,
+ 0x44, 0xD8, 0xB3, 0xD8, 0xAC, 0x44, 0xD8, 0xB3,
+ 0xD8, 0xAD, 0x44, 0xD8, 0xB3, 0xD8, 0xAE, 0x44,
+ 0xD8, 0xB3, 0xD8, 0xB1, 0x44, 0xD8, 0xB3, 0xD9,
+ 0x85, 0x44, 0xD8, 0xB3, 0xD9, 0x87, 0x44, 0xD8,
+ 0xB3, 0xD9, 0x89, 0x44, 0xD8, 0xB3, 0xD9, 0x8A,
+ // Bytes 1fc0 - 1fff
+ 0x44, 0xD8, 0xB4, 0xD8, 0xAC, 0x44, 0xD8, 0xB4,
+ 0xD8, 0xAD, 0x44, 0xD8, 0xB4, 0xD8, 0xAE, 0x44,
+ 0xD8, 0xB4, 0xD8, 0xB1, 0x44, 0xD8, 0xB4, 0xD9,
+ 0x85, 0x44, 0xD8, 0xB4, 0xD9, 0x87, 0x44, 0xD8,
+ 0xB4, 0xD9, 0x89, 0x44, 0xD8, 0xB4, 0xD9, 0x8A,
+ 0x44, 0xD8, 0xB5, 0xD8, 0xAD, 0x44, 0xD8, 0xB5,
+ 0xD8, 0xAE, 0x44, 0xD8, 0xB5, 0xD8, 0xB1, 0x44,
+ 0xD8, 0xB5, 0xD9, 0x85, 0x44, 0xD8, 0xB5, 0xD9,
+ // Bytes 2000 - 203f
+ 0x89, 0x44, 0xD8, 0xB5, 0xD9, 0x8A, 0x44, 0xD8,
+ 0xB6, 0xD8, 0xAC, 0x44, 0xD8, 0xB6, 0xD8, 0xAD,
+ 0x44, 0xD8, 0xB6, 0xD8, 0xAE, 0x44, 0xD8, 0xB6,
+ 0xD8, 0xB1, 0x44, 0xD8, 0xB6, 0xD9, 0x85, 0x44,
+ 0xD8, 0xB6, 0xD9, 0x89, 0x44, 0xD8, 0xB6, 0xD9,
+ 0x8A, 0x44, 0xD8, 0xB7, 0xD8, 0xAD, 0x44, 0xD8,
+ 0xB7, 0xD9, 0x85, 0x44, 0xD8, 0xB7, 0xD9, 0x89,
+ 0x44, 0xD8, 0xB7, 0xD9, 0x8A, 0x44, 0xD8, 0xB8,
+ // Bytes 2040 - 207f
+ 0xD9, 0x85, 0x44, 0xD8, 0xB9, 0xD8, 0xAC, 0x44,
+ 0xD8, 0xB9, 0xD9, 0x85, 0x44, 0xD8, 0xB9, 0xD9,
+ 0x89, 0x44, 0xD8, 0xB9, 0xD9, 0x8A, 0x44, 0xD8,
+ 0xBA, 0xD8, 0xAC, 0x44, 0xD8, 0xBA, 0xD9, 0x85,
+ 0x44, 0xD8, 0xBA, 0xD9, 0x89, 0x44, 0xD8, 0xBA,
+ 0xD9, 0x8A, 0x44, 0xD9, 0x81, 0xD8, 0xAC, 0x44,
+ 0xD9, 0x81, 0xD8, 0xAD, 0x44, 0xD9, 0x81, 0xD8,
+ 0xAE, 0x44, 0xD9, 0x81, 0xD9, 0x85, 0x44, 0xD9,
+ // Bytes 2080 - 20bf
+ 0x81, 0xD9, 0x89, 0x44, 0xD9, 0x81, 0xD9, 0x8A,
+ 0x44, 0xD9, 0x82, 0xD8, 0xAD, 0x44, 0xD9, 0x82,
+ 0xD9, 0x85, 0x44, 0xD9, 0x82, 0xD9, 0x89, 0x44,
+ 0xD9, 0x82, 0xD9, 0x8A, 0x44, 0xD9, 0x83, 0xD8,
+ 0xA7, 0x44, 0xD9, 0x83, 0xD8, 0xAC, 0x44, 0xD9,
+ 0x83, 0xD8, 0xAD, 0x44, 0xD9, 0x83, 0xD8, 0xAE,
+ 0x44, 0xD9, 0x83, 0xD9, 0x84, 0x44, 0xD9, 0x83,
+ 0xD9, 0x85, 0x44, 0xD9, 0x83, 0xD9, 0x89, 0x44,
+ // Bytes 20c0 - 20ff
+ 0xD9, 0x83, 0xD9, 0x8A, 0x44, 0xD9, 0x84, 0xD8,
+ 0xA7, 0x44, 0xD9, 0x84, 0xD8, 0xAC, 0x44, 0xD9,
+ 0x84, 0xD8, 0xAD, 0x44, 0xD9, 0x84, 0xD8, 0xAE,
+ 0x44, 0xD9, 0x84, 0xD9, 0x85, 0x44, 0xD9, 0x84,
+ 0xD9, 0x87, 0x44, 0xD9, 0x84, 0xD9, 0x89, 0x44,
+ 0xD9, 0x84, 0xD9, 0x8A, 0x44, 0xD9, 0x85, 0xD8,
+ 0xA7, 0x44, 0xD9, 0x85, 0xD8, 0xAC, 0x44, 0xD9,
+ 0x85, 0xD8, 0xAD, 0x44, 0xD9, 0x85, 0xD8, 0xAE,
+ // Bytes 2100 - 213f
+ 0x44, 0xD9, 0x85, 0xD9, 0x85, 0x44, 0xD9, 0x85,
+ 0xD9, 0x89, 0x44, 0xD9, 0x85, 0xD9, 0x8A, 0x44,
+ 0xD9, 0x86, 0xD8, 0xAC, 0x44, 0xD9, 0x86, 0xD8,
+ 0xAD, 0x44, 0xD9, 0x86, 0xD8, 0xAE, 0x44, 0xD9,
+ 0x86, 0xD8, 0xB1, 0x44, 0xD9, 0x86, 0xD8, 0xB2,
+ 0x44, 0xD9, 0x86, 0xD9, 0x85, 0x44, 0xD9, 0x86,
+ 0xD9, 0x86, 0x44, 0xD9, 0x86, 0xD9, 0x87, 0x44,
+ 0xD9, 0x86, 0xD9, 0x89, 0x44, 0xD9, 0x86, 0xD9,
+ // Bytes 2140 - 217f
+ 0x8A, 0x44, 0xD9, 0x87, 0xD8, 0xAC, 0x44, 0xD9,
+ 0x87, 0xD9, 0x85, 0x44, 0xD9, 0x87, 0xD9, 0x89,
+ 0x44, 0xD9, 0x87, 0xD9, 0x8A, 0x44, 0xD9, 0x88,
+ 0xD9, 0xB4, 0x44, 0xD9, 0x8A, 0xD8, 0xAC, 0x44,
+ 0xD9, 0x8A, 0xD8, 0xAD, 0x44, 0xD9, 0x8A, 0xD8,
+ 0xAE, 0x44, 0xD9, 0x8A, 0xD8, 0xB1, 0x44, 0xD9,
+ 0x8A, 0xD8, 0xB2, 0x44, 0xD9, 0x8A, 0xD9, 0x85,
+ 0x44, 0xD9, 0x8A, 0xD9, 0x86, 0x44, 0xD9, 0x8A,
+ // Bytes 2180 - 21bf
+ 0xD9, 0x87, 0x44, 0xD9, 0x8A, 0xD9, 0x89, 0x44,
+ 0xD9, 0x8A, 0xD9, 0x8A, 0x44, 0xD9, 0x8A, 0xD9,
+ 0xB4, 0x44, 0xDB, 0x87, 0xD9, 0xB4, 0x45, 0x28,
+ 0xE1, 0x84, 0x80, 0x29, 0x45, 0x28, 0xE1, 0x84,
+ 0x82, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x83, 0x29,
+ 0x45, 0x28, 0xE1, 0x84, 0x85, 0x29, 0x45, 0x28,
+ 0xE1, 0x84, 0x86, 0x29, 0x45, 0x28, 0xE1, 0x84,
+ 0x87, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x89, 0x29,
+ // Bytes 21c0 - 21ff
+ 0x45, 0x28, 0xE1, 0x84, 0x8B, 0x29, 0x45, 0x28,
+ 0xE1, 0x84, 0x8C, 0x29, 0x45, 0x28, 0xE1, 0x84,
+ 0x8E, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x8F, 0x29,
+ 0x45, 0x28, 0xE1, 0x84, 0x90, 0x29, 0x45, 0x28,
+ 0xE1, 0x84, 0x91, 0x29, 0x45, 0x28, 0xE1, 0x84,
+ 0x92, 0x29, 0x45, 0x28, 0xE4, 0xB8, 0x80, 0x29,
+ 0x45, 0x28, 0xE4, 0xB8, 0x83, 0x29, 0x45, 0x28,
+ 0xE4, 0xB8, 0x89, 0x29, 0x45, 0x28, 0xE4, 0xB9,
+ // Bytes 2200 - 223f
+ 0x9D, 0x29, 0x45, 0x28, 0xE4, 0xBA, 0x8C, 0x29,
+ 0x45, 0x28, 0xE4, 0xBA, 0x94, 0x29, 0x45, 0x28,
+ 0xE4, 0xBB, 0xA3, 0x29, 0x45, 0x28, 0xE4, 0xBC,
+ 0x81, 0x29, 0x45, 0x28, 0xE4, 0xBC, 0x91, 0x29,
+ 0x45, 0x28, 0xE5, 0x85, 0xAB, 0x29, 0x45, 0x28,
+ 0xE5, 0x85, 0xAD, 0x29, 0x45, 0x28, 0xE5, 0x8A,
+ 0xB4, 0x29, 0x45, 0x28, 0xE5, 0x8D, 0x81, 0x29,
+ 0x45, 0x28, 0xE5, 0x8D, 0x94, 0x29, 0x45, 0x28,
+ // Bytes 2240 - 227f
+ 0xE5, 0x90, 0x8D, 0x29, 0x45, 0x28, 0xE5, 0x91,
+ 0xBC, 0x29, 0x45, 0x28, 0xE5, 0x9B, 0x9B, 0x29,
+ 0x45, 0x28, 0xE5, 0x9C, 0x9F, 0x29, 0x45, 0x28,
+ 0xE5, 0xAD, 0xA6, 0x29, 0x45, 0x28, 0xE6, 0x97,
+ 0xA5, 0x29, 0x45, 0x28, 0xE6, 0x9C, 0x88, 0x29,
+ 0x45, 0x28, 0xE6, 0x9C, 0x89, 0x29, 0x45, 0x28,
+ 0xE6, 0x9C, 0xA8, 0x29, 0x45, 0x28, 0xE6, 0xA0,
+ 0xAA, 0x29, 0x45, 0x28, 0xE6, 0xB0, 0xB4, 0x29,
+ // Bytes 2280 - 22bf
+ 0x45, 0x28, 0xE7, 0x81, 0xAB, 0x29, 0x45, 0x28,
+ 0xE7, 0x89, 0xB9, 0x29, 0x45, 0x28, 0xE7, 0x9B,
+ 0xA3, 0x29, 0x45, 0x28, 0xE7, 0xA4, 0xBE, 0x29,
+ 0x45, 0x28, 0xE7, 0xA5, 0x9D, 0x29, 0x45, 0x28,
+ 0xE7, 0xA5, 0xAD, 0x29, 0x45, 0x28, 0xE8, 0x87,
+ 0xAA, 0x29, 0x45, 0x28, 0xE8, 0x87, 0xB3, 0x29,
+ 0x45, 0x28, 0xE8, 0xB2, 0xA1, 0x29, 0x45, 0x28,
+ 0xE8, 0xB3, 0x87, 0x29, 0x45, 0x28, 0xE9, 0x87,
+ // Bytes 22c0 - 22ff
+ 0x91, 0x29, 0x45, 0x30, 0xE2, 0x81, 0x84, 0x33,
+ 0x45, 0x31, 0x30, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+ 0x30, 0xE6, 0x9C, 0x88, 0x45, 0x31, 0x30, 0xE7,
+ 0x82, 0xB9, 0x45, 0x31, 0x31, 0xE6, 0x97, 0xA5,
+ 0x45, 0x31, 0x31, 0xE6, 0x9C, 0x88, 0x45, 0x31,
+ 0x31, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x32, 0xE6,
+ 0x97, 0xA5, 0x45, 0x31, 0x32, 0xE6, 0x9C, 0x88,
+ 0x45, 0x31, 0x32, 0xE7, 0x82, 0xB9, 0x45, 0x31,
+ // Bytes 2300 - 233f
+ 0x33, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x33, 0xE7,
+ 0x82, 0xB9, 0x45, 0x31, 0x34, 0xE6, 0x97, 0xA5,
+ 0x45, 0x31, 0x34, 0xE7, 0x82, 0xB9, 0x45, 0x31,
+ 0x35, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x35, 0xE7,
+ 0x82, 0xB9, 0x45, 0x31, 0x36, 0xE6, 0x97, 0xA5,
+ 0x45, 0x31, 0x36, 0xE7, 0x82, 0xB9, 0x45, 0x31,
+ 0x37, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x37, 0xE7,
+ 0x82, 0xB9, 0x45, 0x31, 0x38, 0xE6, 0x97, 0xA5,
+ // Bytes 2340 - 237f
+ 0x45, 0x31, 0x38, 0xE7, 0x82, 0xB9, 0x45, 0x31,
+ 0x39, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x39, 0xE7,
+ 0x82, 0xB9, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x32,
+ 0x45, 0x31, 0xE2, 0x81, 0x84, 0x33, 0x45, 0x31,
+ 0xE2, 0x81, 0x84, 0x34, 0x45, 0x31, 0xE2, 0x81,
+ 0x84, 0x35, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x36,
+ 0x45, 0x31, 0xE2, 0x81, 0x84, 0x37, 0x45, 0x31,
+ 0xE2, 0x81, 0x84, 0x38, 0x45, 0x31, 0xE2, 0x81,
+ // Bytes 2380 - 23bf
+ 0x84, 0x39, 0x45, 0x32, 0x30, 0xE6, 0x97, 0xA5,
+ 0x45, 0x32, 0x30, 0xE7, 0x82, 0xB9, 0x45, 0x32,
+ 0x31, 0xE6, 0x97, 0xA5, 0x45, 0x32, 0x31, 0xE7,
+ 0x82, 0xB9, 0x45, 0x32, 0x32, 0xE6, 0x97, 0xA5,
+ 0x45, 0x32, 0x32, 0xE7, 0x82, 0xB9, 0x45, 0x32,
+ 0x33, 0xE6, 0x97, 0xA5, 0x45, 0x32, 0x33, 0xE7,
+ 0x82, 0xB9, 0x45, 0x32, 0x34, 0xE6, 0x97, 0xA5,
+ 0x45, 0x32, 0x34, 0xE7, 0x82, 0xB9, 0x45, 0x32,
+ // Bytes 23c0 - 23ff
+ 0x35, 0xE6, 0x97, 0xA5, 0x45, 0x32, 0x36, 0xE6,
+ 0x97, 0xA5, 0x45, 0x32, 0x37, 0xE6, 0x97, 0xA5,
+ 0x45, 0x32, 0x38, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+ 0x39, 0xE6, 0x97, 0xA5, 0x45, 0x32, 0xE2, 0x81,
+ 0x84, 0x33, 0x45, 0x32, 0xE2, 0x81, 0x84, 0x35,
+ 0x45, 0x33, 0x30, 0xE6, 0x97, 0xA5, 0x45, 0x33,
+ 0x31, 0xE6, 0x97, 0xA5, 0x45, 0x33, 0xE2, 0x81,
+ 0x84, 0x34, 0x45, 0x33, 0xE2, 0x81, 0x84, 0x35,
+ // Bytes 2400 - 243f
+ 0x45, 0x33, 0xE2, 0x81, 0x84, 0x38, 0x45, 0x34,
+ 0xE2, 0x81, 0x84, 0x35, 0x45, 0x35, 0xE2, 0x81,
+ 0x84, 0x36, 0x45, 0x35, 0xE2, 0x81, 0x84, 0x38,
+ 0x45, 0x37, 0xE2, 0x81, 0x84, 0x38, 0x45, 0x41,
+ 0xE2, 0x88, 0x95, 0x6D, 0x45, 0x56, 0xE2, 0x88,
+ 0x95, 0x6D, 0x45, 0x6D, 0xE2, 0x88, 0x95, 0x73,
+ 0x46, 0x31, 0xE2, 0x81, 0x84, 0x31, 0x30, 0x46,
+ 0x43, 0xE2, 0x88, 0x95, 0x6B, 0x67, 0x46, 0x6D,
+ // Bytes 2440 - 247f
+ 0xE2, 0x88, 0x95, 0x73, 0x32, 0x46, 0xD8, 0xA8,
+ 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD8, 0xA8, 0xD8,
+ 0xAE, 0xD9, 0x8A, 0x46, 0xD8, 0xAA, 0xD8, 0xAC,
+ 0xD9, 0x85, 0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9,
+ 0x89, 0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x8A,
+ 0x46, 0xD8, 0xAA, 0xD8, 0xAD, 0xD8, 0xAC, 0x46,
+ 0xD8, 0xAA, 0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD8,
+ 0xAA, 0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD8, 0xAA,
+ // Bytes 2480 - 24bf
+ 0xD8, 0xAE, 0xD9, 0x89, 0x46, 0xD8, 0xAA, 0xD8,
+ 0xAE, 0xD9, 0x8A, 0x46, 0xD8, 0xAA, 0xD9, 0x85,
+ 0xD8, 0xAC, 0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8,
+ 0xAD, 0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAE,
+ 0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD9, 0x89, 0x46,
+ 0xD8, 0xAA, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8,
+ 0xAC, 0xD8, 0xAD, 0xD9, 0x89, 0x46, 0xD8, 0xAC,
+ 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD8, 0xAC, 0xD9,
+ // Bytes 24c0 - 24ff
+ 0x85, 0xD8, 0xAD, 0x46, 0xD8, 0xAC, 0xD9, 0x85,
+ 0xD9, 0x89, 0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD9,
+ 0x8A, 0x46, 0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x8A,
+ 0x46, 0xD8, 0xAD, 0xD9, 0x85, 0xD9, 0x89, 0x46,
+ 0xD8, 0xAD, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8,
+ 0xB3, 0xD8, 0xAC, 0xD8, 0xAD, 0x46, 0xD8, 0xB3,
+ 0xD8, 0xAC, 0xD9, 0x89, 0x46, 0xD8, 0xB3, 0xD8,
+ 0xAD, 0xD8, 0xAC, 0x46, 0xD8, 0xB3, 0xD8, 0xAE,
+ // Bytes 2500 - 253f
+ 0xD9, 0x89, 0x46, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9,
+ 0x8A, 0x46, 0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xAC,
+ 0x46, 0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xAD, 0x46,
+ 0xD8, 0xB3, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8,
+ 0xB4, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD8, 0xB4,
+ 0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD8, 0xB4, 0xD8,
+ 0xAD, 0xD9, 0x8A, 0x46, 0xD8, 0xB4, 0xD9, 0x85,
+ 0xD8, 0xAE, 0x46, 0xD8, 0xB4, 0xD9, 0x85, 0xD9,
+ // Bytes 2540 - 257f
+ 0x85, 0x46, 0xD8, 0xB5, 0xD8, 0xAD, 0xD8, 0xAD,
+ 0x46, 0xD8, 0xB5, 0xD8, 0xAD, 0xD9, 0x8A, 0x46,
+ 0xD8, 0xB5, 0xD9, 0x84, 0xD9, 0x89, 0x46, 0xD8,
+ 0xB5, 0xD9, 0x84, 0xDB, 0x92, 0x46, 0xD8, 0xB5,
+ 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB6, 0xD8,
+ 0xAD, 0xD9, 0x89, 0x46, 0xD8, 0xB6, 0xD8, 0xAD,
+ 0xD9, 0x8A, 0x46, 0xD8, 0xB6, 0xD8, 0xAE, 0xD9,
+ 0x85, 0x46, 0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xAD,
+ // Bytes 2580 - 25bf
+ 0x46, 0xD8, 0xB7, 0xD9, 0x85, 0xD9, 0x85, 0x46,
+ 0xD8, 0xB7, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8,
+ 0xB9, 0xD8, 0xAC, 0xD9, 0x85, 0x46, 0xD8, 0xB9,
+ 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB9, 0xD9,
+ 0x85, 0xD9, 0x89, 0x46, 0xD8, 0xB9, 0xD9, 0x85,
+ 0xD9, 0x8A, 0x46, 0xD8, 0xBA, 0xD9, 0x85, 0xD9,
+ 0x85, 0x46, 0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x89,
+ 0x46, 0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+ // Bytes 25c0 - 25ff
+ 0xD9, 0x81, 0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9,
+ 0x81, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x82,
+ 0xD9, 0x84, 0xDB, 0x92, 0x46, 0xD9, 0x82, 0xD9,
+ 0x85, 0xD8, 0xAD, 0x46, 0xD9, 0x82, 0xD9, 0x85,
+ 0xD9, 0x85, 0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD9,
+ 0x8A, 0x46, 0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x85,
+ 0x46, 0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+ 0xD9, 0x84, 0xD8, 0xAC, 0xD8, 0xAC, 0x46, 0xD9,
+ // Bytes 2600 - 263f
+ 0x84, 0xD8, 0xAC, 0xD9, 0x85, 0x46, 0xD9, 0x84,
+ 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD9, 0x84, 0xD8,
+ 0xAD, 0xD9, 0x85, 0x46, 0xD9, 0x84, 0xD8, 0xAD,
+ 0xD9, 0x89, 0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9,
+ 0x8A, 0x46, 0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x85,
+ 0x46, 0xD9, 0x84, 0xD9, 0x85, 0xD8, 0xAD, 0x46,
+ 0xD9, 0x84, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9,
+ 0x85, 0xD8, 0xAC, 0xD8, 0xAD, 0x46, 0xD9, 0x85,
+ // Bytes 2640 - 267f
+ 0xD8, 0xAC, 0xD8, 0xAE, 0x46, 0xD9, 0x85, 0xD8,
+ 0xAC, 0xD9, 0x85, 0x46, 0xD9, 0x85, 0xD8, 0xAC,
+ 0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD8, 0xAD, 0xD8,
+ 0xAC, 0x46, 0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x85,
+ 0x46, 0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x8A, 0x46,
+ 0xD9, 0x85, 0xD8, 0xAE, 0xD8, 0xAC, 0x46, 0xD9,
+ 0x85, 0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9, 0x85,
+ 0xD8, 0xAE, 0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD9,
+ // Bytes 2680 - 26bf
+ 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x86, 0xD8, 0xAC,
+ 0xD8, 0xAD, 0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD9,
+ 0x85, 0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x89,
+ 0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x8A, 0x46,
+ 0xD9, 0x86, 0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD9,
+ 0x86, 0xD8, 0xAD, 0xD9, 0x89, 0x46, 0xD9, 0x86,
+ 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9, 0x86, 0xD9,
+ 0x85, 0xD9, 0x89, 0x46, 0xD9, 0x86, 0xD9, 0x85,
+ // Bytes 26c0 - 26ff
+ 0xD9, 0x8A, 0x46, 0xD9, 0x87, 0xD9, 0x85, 0xD8,
+ 0xAC, 0x46, 0xD9, 0x87, 0xD9, 0x85, 0xD9, 0x85,
+ 0x46, 0xD9, 0x8A, 0xD8, 0xAC, 0xD9, 0x8A, 0x46,
+ 0xD9, 0x8A, 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9,
+ 0x8A, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD9, 0x8A,
+ 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x8A, 0xD9,
+ 0x94, 0xD8, 0xA7, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+ 0xD8, 0xAC, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+ // Bytes 2700 - 273f
+ 0xAD, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAE,
+ 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xB1, 0x46,
+ 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xB2, 0x46, 0xD9,
+ 0x8A, 0xD9, 0x94, 0xD9, 0x85, 0x46, 0xD9, 0x8A,
+ 0xD9, 0x94, 0xD9, 0x86, 0x46, 0xD9, 0x8A, 0xD9,
+ 0x94, 0xD9, 0x87, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+ 0xD9, 0x88, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9,
+ 0x89, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x8A,
+ // Bytes 2740 - 277f
+ 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x86, 0x46,
+ 0xD9, 0x8A, 0xD9, 0x94, 0xDB, 0x87, 0x46, 0xD9,
+ 0x8A, 0xD9, 0x94, 0xDB, 0x88, 0x46, 0xD9, 0x8A,
+ 0xD9, 0x94, 0xDB, 0x90, 0x46, 0xD9, 0x8A, 0xD9,
+ 0x94, 0xDB, 0x95, 0x46, 0xE0, 0xB9, 0x8D, 0xE0,
+ 0xB8, 0xB2, 0x46, 0xE0, 0xBA, 0xAB, 0xE0, 0xBA,
+ 0x99, 0x46, 0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0xA1,
+ 0x46, 0xE0, 0xBB, 0x8D, 0xE0, 0xBA, 0xB2, 0x46,
+ // Bytes 2780 - 27bf
+ 0xE0, 0xBD, 0x80, 0xE0, 0xBE, 0xB5, 0x46, 0xE0,
+ 0xBD, 0x82, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBD,
+ 0x8C, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x91,
+ 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x96, 0xE0,
+ 0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x9B, 0xE0, 0xBE,
+ 0xB7, 0x46, 0xE0, 0xBE, 0x90, 0xE0, 0xBE, 0xB5,
+ 0x46, 0xE0, 0xBE, 0x92, 0xE0, 0xBE, 0xB7, 0x46,
+ 0xE0, 0xBE, 0x9C, 0xE0, 0xBE, 0xB7, 0x46, 0xE0,
+ // Bytes 27c0 - 27ff
+ 0xBE, 0xA1, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE,
+ 0xA6, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xAB,
+ 0xE0, 0xBE, 0xB7, 0x46, 0xE1, 0x84, 0x80, 0xE1,
+ 0x85, 0xA1, 0x46, 0xE1, 0x84, 0x82, 0xE1, 0x85,
+ 0xA1, 0x46, 0xE1, 0x84, 0x83, 0xE1, 0x85, 0xA1,
+ 0x46, 0xE1, 0x84, 0x85, 0xE1, 0x85, 0xA1, 0x46,
+ 0xE1, 0x84, 0x86, 0xE1, 0x85, 0xA1, 0x46, 0xE1,
+ 0x84, 0x87, 0xE1, 0x85, 0xA1, 0x46, 0xE1, 0x84,
+ // Bytes 2800 - 283f
+ 0x89, 0xE1, 0x85, 0xA1, 0x46, 0xE1, 0x84, 0x8B,
+ 0xE1, 0x85, 0xA1, 0x46, 0xE1, 0x84, 0x8B, 0xE1,
+ 0x85, 0xAE, 0x46, 0xE1, 0x84, 0x8C, 0xE1, 0x85,
+ 0xA1, 0x46, 0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1,
+ 0x46, 0xE1, 0x84, 0x8F, 0xE1, 0x85, 0xA1, 0x46,
+ 0xE1, 0x84, 0x90, 0xE1, 0x85, 0xA1, 0x46, 0xE1,
+ 0x84, 0x91, 0xE1, 0x85, 0xA1, 0x46, 0xE1, 0x84,
+ 0x92, 0xE1, 0x85, 0xA1, 0x46, 0xE2, 0x80, 0xB2,
+ // Bytes 2840 - 287f
+ 0xE2, 0x80, 0xB2, 0x46, 0xE2, 0x80, 0xB5, 0xE2,
+ 0x80, 0xB5, 0x46, 0xE2, 0x88, 0xAB, 0xE2, 0x88,
+ 0xAB, 0x46, 0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE,
+ 0x46, 0xE3, 0x81, 0xBB, 0xE3, 0x81, 0x8B, 0x46,
+ 0xE3, 0x82, 0x88, 0xE3, 0x82, 0x8A, 0x46, 0xE3,
+ 0x82, 0xAD, 0xE3, 0x83, 0xAD, 0x46, 0xE3, 0x82,
+ 0xB3, 0xE3, 0x82, 0xB3, 0x46, 0xE3, 0x82, 0xB3,
+ 0xE3, 0x83, 0x88, 0x46, 0xE3, 0x83, 0x88, 0xE3,
+ // Bytes 2880 - 28bf
+ 0x83, 0xB3, 0x46, 0xE3, 0x83, 0x8A, 0xE3, 0x83,
+ 0x8E, 0x46, 0xE3, 0x83, 0x9B, 0xE3, 0x83, 0xB3,
+ 0x46, 0xE3, 0x83, 0x9F, 0xE3, 0x83, 0xAA, 0x46,
+ 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xA9, 0x46, 0xE3,
+ 0x83, 0xAC, 0xE3, 0x83, 0xA0, 0x46, 0xE5, 0xA4,
+ 0xA7, 0xE6, 0xAD, 0xA3, 0x46, 0xE5, 0xB9, 0xB3,
+ 0xE6, 0x88, 0x90, 0x46, 0xE6, 0x98, 0x8E, 0xE6,
+ 0xB2, 0xBB, 0x46, 0xE6, 0x98, 0xAD, 0xE5, 0x92,
+ // Bytes 28c0 - 28ff
+ 0x8C, 0x47, 0x72, 0x61, 0x64, 0xE2, 0x88, 0x95,
+ 0x73, 0x47, 0xE3, 0x80, 0x94, 0x53, 0xE3, 0x80,
+ 0x95, 0x48, 0x28, 0xE1, 0x84, 0x80, 0xE1, 0x85,
+ 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x82, 0xE1,
+ 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x83,
+ 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+ 0x85, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1,
+ 0x84, 0x86, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28,
+ // Bytes 2900 - 293f
+ 0xE1, 0x84, 0x87, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+ 0x28, 0xE1, 0x84, 0x89, 0xE1, 0x85, 0xA1, 0x29,
+ 0x48, 0x28, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xA1,
+ 0x29, 0x48, 0x28, 0xE1, 0x84, 0x8C, 0xE1, 0x85,
+ 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x8C, 0xE1,
+ 0x85, 0xAE, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x8E,
+ 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+ 0x8F, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1,
+ // Bytes 2940 - 297f
+ 0x84, 0x90, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28,
+ 0xE1, 0x84, 0x91, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+ 0x28, 0xE1, 0x84, 0x92, 0xE1, 0x85, 0xA1, 0x29,
+ 0x48, 0x72, 0x61, 0x64, 0xE2, 0x88, 0x95, 0x73,
+ 0x32, 0x48, 0xD8, 0xA7, 0xD9, 0x83, 0xD8, 0xA8,
+ 0xD8, 0xB1, 0x48, 0xD8, 0xA7, 0xD9, 0x84, 0xD9,
+ 0x84, 0xD9, 0x87, 0x48, 0xD8, 0xB1, 0xD8, 0xB3,
+ 0xD9, 0x88, 0xD9, 0x84, 0x48, 0xD8, 0xB1, 0xDB,
+ // Bytes 2980 - 29bf
+ 0x8C, 0xD8, 0xA7, 0xD9, 0x84, 0x48, 0xD8, 0xB5,
+ 0xD9, 0x84, 0xD8, 0xB9, 0xD9, 0x85, 0x48, 0xD8,
+ 0xB9, 0xD9, 0x84, 0xD9, 0x8A, 0xD9, 0x87, 0x48,
+ 0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x85, 0xD8, 0xAF,
+ 0x48, 0xD9, 0x88, 0xD8, 0xB3, 0xD9, 0x84, 0xD9,
+ 0x85, 0x49, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+ 0xE2, 0x80, 0xB2, 0x49, 0xE2, 0x80, 0xB5, 0xE2,
+ 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0x49, 0xE2, 0x88,
+ // Bytes 29c0 - 29ff
+ 0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0x49,
+ 0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE, 0xE2, 0x88,
+ 0xAE, 0x49, 0xE3, 0x80, 0x94, 0xE4, 0xB8, 0x89,
+ 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE4,
+ 0xBA, 0x8C, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80,
+ 0x94, 0xE5, 0x8B, 0x9D, 0xE3, 0x80, 0x95, 0x49,
+ 0xE3, 0x80, 0x94, 0xE5, 0xAE, 0x89, 0xE3, 0x80,
+ 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE6, 0x89, 0x93,
+ // Bytes 2a00 - 2a3f
+ 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE6,
+ 0x95, 0x97, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80,
+ 0x94, 0xE6, 0x9C, 0xAC, 0xE3, 0x80, 0x95, 0x49,
+ 0xE3, 0x80, 0x94, 0xE7, 0x82, 0xB9, 0xE3, 0x80,
+ 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE7, 0x9B, 0x97,
+ 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x82, 0xA2, 0xE3,
+ 0x83, 0xBC, 0xE3, 0x83, 0xAB, 0x49, 0xE3, 0x82,
+ 0xA4, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x81, 0x49,
+ // Bytes 2a40 - 2a7f
+ 0xE3, 0x82, 0xA6, 0xE3, 0x82, 0xA9, 0xE3, 0x83,
+ 0xB3, 0x49, 0xE3, 0x82, 0xAA, 0xE3, 0x83, 0xB3,
+ 0xE3, 0x82, 0xB9, 0x49, 0xE3, 0x82, 0xAA, 0xE3,
+ 0x83, 0xBC, 0xE3, 0x83, 0xA0, 0x49, 0xE3, 0x82,
+ 0xAB, 0xE3, 0x82, 0xA4, 0xE3, 0x83, 0xAA, 0x49,
+ 0xE3, 0x82, 0xB1, 0xE3, 0x83, 0xBC, 0xE3, 0x82,
+ 0xB9, 0x49, 0xE3, 0x82, 0xB3, 0xE3, 0x83, 0xAB,
+ 0xE3, 0x83, 0x8A, 0x49, 0xE3, 0x82, 0xBB, 0xE3,
+ // Bytes 2a80 - 2abf
+ 0x83, 0xB3, 0xE3, 0x83, 0x81, 0x49, 0xE3, 0x82,
+ 0xBB, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88, 0x49,
+ 0xE3, 0x83, 0x86, 0xE3, 0x82, 0x99, 0xE3, 0x82,
+ 0xB7, 0x49, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99,
+ 0xE3, 0x83, 0xAB, 0x49, 0xE3, 0x83, 0x8E, 0xE3,
+ 0x83, 0x83, 0xE3, 0x83, 0x88, 0x49, 0xE3, 0x83,
+ 0x8F, 0xE3, 0x82, 0xA4, 0xE3, 0x83, 0x84, 0x49,
+ 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+ // Bytes 2ac0 - 2aff
+ 0xAB, 0x49, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A,
+ 0xE3, 0x82, 0xB3, 0x49, 0xE3, 0x83, 0x95, 0xE3,
+ 0x83, 0xA9, 0xE3, 0x83, 0xB3, 0x49, 0xE3, 0x83,
+ 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xBD, 0x49,
+ 0xE3, 0x83, 0x98, 0xE3, 0x83, 0xAB, 0xE3, 0x83,
+ 0x84, 0x49, 0xE3, 0x83, 0x9B, 0xE3, 0x83, 0xBC,
+ 0xE3, 0x83, 0xAB, 0x49, 0xE3, 0x83, 0x9B, 0xE3,
+ 0x83, 0xBC, 0xE3, 0x83, 0xB3, 0x49, 0xE3, 0x83,
+ // Bytes 2b00 - 2b3f
+ 0x9E, 0xE3, 0x82, 0xA4, 0xE3, 0x83, 0xAB, 0x49,
+ 0xE3, 0x83, 0x9E, 0xE3, 0x83, 0x83, 0xE3, 0x83,
+ 0x8F, 0x49, 0xE3, 0x83, 0x9E, 0xE3, 0x83, 0xAB,
+ 0xE3, 0x82, 0xAF, 0x49, 0xE3, 0x83, 0xA4, 0xE3,
+ 0x83, 0xBC, 0xE3, 0x83, 0xAB, 0x49, 0xE3, 0x83,
+ 0xA6, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xB3, 0x49,
+ 0xE3, 0x83, 0xAF, 0xE3, 0x83, 0x83, 0xE3, 0x83,
+ 0x88, 0x4C, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xAE,
+ // Bytes 2b40 - 2b7f
+ 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xB4, 0x4C, 0xE2,
+ 0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+ 0xE2, 0x80, 0xB2, 0x4C, 0xE2, 0x88, 0xAB, 0xE2,
+ 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB,
+ 0x4C, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xAB, 0xE3,
+ 0x83, 0x95, 0xE3, 0x82, 0xA1, 0x4C, 0xE3, 0x82,
+ 0xA8, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAB, 0xE3,
+ 0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+ // Bytes 2b80 - 2bbf
+ 0x99, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xB3, 0x4C,
+ 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+ 0xB3, 0xE3, 0x83, 0x9E, 0x4C, 0xE3, 0x82, 0xAB,
+ 0xE3, 0x83, 0xA9, 0xE3, 0x83, 0x83, 0xE3, 0x83,
+ 0x88, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x83, 0xAD,
+ 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC, 0x4C, 0xE3,
+ 0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0x8B,
+ 0xE3, 0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAD, 0xE3,
+ // Bytes 2bc0 - 2bff
+ 0x83, 0xA5, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC,
+ 0x4C, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3,
+ 0x83, 0xA9, 0xE3, 0x83, 0xA0, 0x4C, 0xE3, 0x82,
+ 0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xBC, 0xE3,
+ 0x83, 0x8D, 0x4C, 0xE3, 0x82, 0xB5, 0xE3, 0x82,
+ 0xA4, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C,
+ 0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+ 0xBC, 0xE3, 0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x8F,
+ // Bytes 2c00 - 2c3f
+ 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+ 0x84, 0x4C, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A,
+ 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+ 0x83, 0x95, 0xE3, 0x82, 0xA3, 0xE3, 0x83, 0xBC,
+ 0xE3, 0x83, 0x88, 0x4C, 0xE3, 0x83, 0x98, 0xE3,
+ 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xBF,
+ 0x4C, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3,
+ 0x83, 0x8B, 0xE3, 0x83, 0x92, 0x4C, 0xE3, 0x83,
+ // Bytes 2c40 - 2c7f
+ 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xB3, 0xE3,
+ 0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x9B, 0xE3, 0x82,
+ 0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x88, 0x4C,
+ 0xE3, 0x83, 0x9E, 0xE3, 0x82, 0xA4, 0xE3, 0x82,
+ 0xAF, 0xE3, 0x83, 0xAD, 0x4C, 0xE3, 0x83, 0x9F,
+ 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83,
+ 0xB3, 0x4C, 0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xBC,
+ 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+ // Bytes 2c80 - 2cbf
+ 0x83, 0xAA, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88,
+ 0xE3, 0x83, 0xAB, 0x4C, 0xE3, 0x83, 0xAB, 0xE3,
+ 0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+ 0x4C, 0xE6, 0xA0, 0xAA, 0xE5, 0xBC, 0x8F, 0xE4,
+ 0xBC, 0x9A, 0xE7, 0xA4, 0xBE, 0x4E, 0x28, 0xE1,
+ 0x84, 0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x92,
+ 0xE1, 0x85, 0xAE, 0x29, 0x4F, 0xD8, 0xAC, 0xD9,
+ 0x84, 0x20, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xA7,
+ // Bytes 2cc0 - 2cff
+ 0xD9, 0x84, 0xD9, 0x87, 0x4F, 0xE1, 0x84, 0x8E,
+ 0xE1, 0x85, 0xA1, 0xE1, 0x86, 0xB7, 0xE1, 0x84,
+ 0x80, 0xE1, 0x85, 0xA9, 0x4F, 0xE3, 0x82, 0xA2,
+ 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+ 0xBC, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xA2,
+ 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+ 0x9A, 0xE3, 0x82, 0xA2, 0x4F, 0xE3, 0x82, 0xAD,
+ 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xAF, 0xE3, 0x83,
+ // Bytes 2d00 - 2d3f
+ 0x83, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xB5,
+ 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x81, 0xE3, 0x83,
+ 0xBC, 0xE3, 0x83, 0xA0, 0x4F, 0xE3, 0x83, 0x8F,
+ 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+ 0xAC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x98,
+ 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0xBF, 0xE3, 0x83,
+ 0xBC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x9B,
+ 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+ // Bytes 2d40 - 2d7f
+ 0xB3, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x83, 0x9E,
+ 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB7, 0xE3, 0x83,
+ 0xA7, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xA1,
+ 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+ 0x88, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xAB,
+ 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+ 0x99, 0xE3, 0x83, 0xAB, 0x51, 0x28, 0xE1, 0x84,
+ 0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x8C, 0xE1,
+ // Bytes 2d80 - 2dbf
+ 0x85, 0xA5, 0xE1, 0x86, 0xAB, 0x29, 0x52, 0xE3,
+ 0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+ 0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+ 0xBC, 0x52, 0xE3, 0x82, 0xAD, 0xE3, 0x83, 0xAD,
+ 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+ 0xA9, 0xE3, 0x83, 0xA0, 0x52, 0xE3, 0x82, 0xAD,
+ 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xA1, 0xE3, 0x83,
+ 0xBC, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x52,
+ // Bytes 2dc0 - 2dff
+ 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+ 0xA9, 0xE3, 0x83, 0xA0, 0xE3, 0x83, 0x88, 0xE3,
+ 0x83, 0xB3, 0x52, 0xE3, 0x82, 0xAF, 0xE3, 0x83,
+ 0xAB, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99, 0xE3,
+ 0x82, 0xA4, 0xE3, 0x83, 0xAD, 0x52, 0xE3, 0x83,
+ 0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3,
+ 0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88,
+ 0x52, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3,
+ // Bytes 2e00 - 2e3f
+ 0x82, 0xA2, 0xE3, 0x82, 0xB9, 0xE3, 0x83, 0x88,
+ 0xE3, 0x83, 0xAB, 0x52, 0xE3, 0x83, 0x95, 0xE3,
+ 0x82, 0x99, 0xE3, 0x83, 0x83, 0xE3, 0x82, 0xB7,
+ 0xE3, 0x82, 0xA7, 0xE3, 0x83, 0xAB, 0x52, 0xE3,
+ 0x83, 0x9F, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0x8F,
+ 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+ 0xAB, 0x52, 0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xB3,
+ 0xE3, 0x83, 0x88, 0xE3, 0x82, 0xB1, 0xE3, 0x82,
+ // Bytes 2e40 - 2e7f
+ 0x99, 0xE3, 0x83, 0xB3, 0x61, 0xD8, 0xB5, 0xD9,
+ 0x84, 0xD9, 0x89, 0x20, 0xD8, 0xA7, 0xD9, 0x84,
+ 0xD9, 0x84, 0xD9, 0x87, 0x20, 0xD8, 0xB9, 0xD9,
+ 0x84, 0xD9, 0x8A, 0xD9, 0x87, 0x20, 0xD9, 0x88,
+ 0xD8, 0xB3, 0xD9, 0x84, 0xD9, 0x85, 0x86, 0xE0,
+ 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0x86, 0xE0, 0xB7,
+ 0x99, 0xE0, 0xB7, 0x8F, 0x09, 0xE0, 0xB7, 0x99,
+ 0xE0, 0xB7, 0x8F, 0xE0, 0xB7, 0x8A, 0x09, 0x44,
+ // Bytes 2e80 - 2ebf
+ 0x44, 0x5A, 0xCC, 0x8C, 0xE6, 0x44, 0x44, 0x7A,
+ 0xCC, 0x8C, 0xE6, 0x44, 0x64, 0x7A, 0xCC, 0x8C,
+ 0xE6, 0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x93,
+ 0xE6, 0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x94,
+ 0xE6, 0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x95,
+ 0xDC, 0x49, 0xE3, 0x83, 0xA1, 0xE3, 0x82, 0xAB,
+ 0xE3, 0x82, 0x99, 0x08, 0x4C, 0xE3, 0x82, 0xAD,
+ 0xE3, 0x82, 0x99, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+ // Bytes 2ec0 - 2eff
+ 0x99, 0x08, 0x4C, 0xE3, 0x82, 0xB3, 0xE3, 0x83,
+ 0xBC, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A, 0x08,
+ 0x4C, 0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xBC, 0xE3,
+ 0x83, 0x88, 0xE3, 0x82, 0x99, 0x08, 0x4F, 0xE3,
+ 0x82, 0xA4, 0xE3, 0x83, 0x8B, 0xE3, 0x83, 0xB3,
+ 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0x08, 0x4F,
+ 0xE3, 0x82, 0xB7, 0xE3, 0x83, 0xAA, 0xE3, 0x83,
+ 0xB3, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0x08,
+ // Bytes 2f00 - 2f3f
+ 0x4F, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3,
+ 0x83, 0xBC, 0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99,
+ 0x08, 0x4F, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A,
+ 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x82,
+ 0x99, 0x08, 0x52, 0xE3, 0x82, 0xA8, 0xE3, 0x82,
+ 0xB9, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xBC, 0xE3,
+ 0x83, 0x88, 0xE3, 0x82, 0x99, 0x08, 0x52, 0xE3,
+ 0x83, 0x95, 0xE3, 0x82, 0xA1, 0xE3, 0x83, 0xA9,
+ // Bytes 2f40 - 2f7f
+ 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0xE3, 0x82,
+ 0x99, 0x08, 0x03, 0x3C, 0xCC, 0xB8, 0x01, 0x03,
+ 0x3D, 0xCC, 0xB8, 0x01, 0x03, 0x3E, 0xCC, 0xB8,
+ 0x01, 0x03, 0x41, 0xCC, 0x80, 0xE6, 0x03, 0x41,
+ 0xCC, 0x81, 0xE6, 0x03, 0x41, 0xCC, 0x83, 0xE6,
+ 0x03, 0x41, 0xCC, 0x84, 0xE6, 0x03, 0x41, 0xCC,
+ 0x89, 0xE6, 0x03, 0x41, 0xCC, 0x8C, 0xE6, 0x03,
+ 0x41, 0xCC, 0x8F, 0xE6, 0x03, 0x41, 0xCC, 0x91,
+ // Bytes 2f80 - 2fbf
+ 0xE6, 0x03, 0x41, 0xCC, 0xA5, 0xDC, 0x03, 0x41,
+ 0xCC, 0xA8, 0xCA, 0x03, 0x42, 0xCC, 0x87, 0xE6,
+ 0x03, 0x42, 0xCC, 0xA3, 0xDC, 0x03, 0x42, 0xCC,
+ 0xB1, 0xDC, 0x03, 0x43, 0xCC, 0x81, 0xE6, 0x03,
+ 0x43, 0xCC, 0x82, 0xE6, 0x03, 0x43, 0xCC, 0x87,
+ 0xE6, 0x03, 0x43, 0xCC, 0x8C, 0xE6, 0x03, 0x44,
+ 0xCC, 0x87, 0xE6, 0x03, 0x44, 0xCC, 0x8C, 0xE6,
+ 0x03, 0x44, 0xCC, 0xA3, 0xDC, 0x03, 0x44, 0xCC,
+ // Bytes 2fc0 - 2fff
+ 0xA7, 0xCA, 0x03, 0x44, 0xCC, 0xAD, 0xDC, 0x03,
+ 0x44, 0xCC, 0xB1, 0xDC, 0x03, 0x45, 0xCC, 0x80,
+ 0xE6, 0x03, 0x45, 0xCC, 0x81, 0xE6, 0x03, 0x45,
+ 0xCC, 0x83, 0xE6, 0x03, 0x45, 0xCC, 0x86, 0xE6,
+ 0x03, 0x45, 0xCC, 0x87, 0xE6, 0x03, 0x45, 0xCC,
+ 0x88, 0xE6, 0x03, 0x45, 0xCC, 0x89, 0xE6, 0x03,
+ 0x45, 0xCC, 0x8C, 0xE6, 0x03, 0x45, 0xCC, 0x8F,
+ 0xE6, 0x03, 0x45, 0xCC, 0x91, 0xE6, 0x03, 0x45,
+ // Bytes 3000 - 303f
+ 0xCC, 0xA8, 0xCA, 0x03, 0x45, 0xCC, 0xAD, 0xDC,
+ 0x03, 0x45, 0xCC, 0xB0, 0xDC, 0x03, 0x46, 0xCC,
+ 0x87, 0xE6, 0x03, 0x47, 0xCC, 0x81, 0xE6, 0x03,
+ 0x47, 0xCC, 0x82, 0xE6, 0x03, 0x47, 0xCC, 0x84,
+ 0xE6, 0x03, 0x47, 0xCC, 0x86, 0xE6, 0x03, 0x47,
+ 0xCC, 0x87, 0xE6, 0x03, 0x47, 0xCC, 0x8C, 0xE6,
+ 0x03, 0x47, 0xCC, 0xA7, 0xCA, 0x03, 0x48, 0xCC,
+ 0x82, 0xE6, 0x03, 0x48, 0xCC, 0x87, 0xE6, 0x03,
+ // Bytes 3040 - 307f
+ 0x48, 0xCC, 0x88, 0xE6, 0x03, 0x48, 0xCC, 0x8C,
+ 0xE6, 0x03, 0x48, 0xCC, 0xA3, 0xDC, 0x03, 0x48,
+ 0xCC, 0xA7, 0xCA, 0x03, 0x48, 0xCC, 0xAE, 0xDC,
+ 0x03, 0x49, 0xCC, 0x80, 0xE6, 0x03, 0x49, 0xCC,
+ 0x81, 0xE6, 0x03, 0x49, 0xCC, 0x82, 0xE6, 0x03,
+ 0x49, 0xCC, 0x83, 0xE6, 0x03, 0x49, 0xCC, 0x84,
+ 0xE6, 0x03, 0x49, 0xCC, 0x86, 0xE6, 0x03, 0x49,
+ 0xCC, 0x87, 0xE6, 0x03, 0x49, 0xCC, 0x89, 0xE6,
+ // Bytes 3080 - 30bf
+ 0x03, 0x49, 0xCC, 0x8C, 0xE6, 0x03, 0x49, 0xCC,
+ 0x8F, 0xE6, 0x03, 0x49, 0xCC, 0x91, 0xE6, 0x03,
+ 0x49, 0xCC, 0xA3, 0xDC, 0x03, 0x49, 0xCC, 0xA8,
+ 0xCA, 0x03, 0x49, 0xCC, 0xB0, 0xDC, 0x03, 0x4A,
+ 0xCC, 0x82, 0xE6, 0x03, 0x4B, 0xCC, 0x81, 0xE6,
+ 0x03, 0x4B, 0xCC, 0x8C, 0xE6, 0x03, 0x4B, 0xCC,
+ 0xA3, 0xDC, 0x03, 0x4B, 0xCC, 0xA7, 0xCA, 0x03,
+ 0x4B, 0xCC, 0xB1, 0xDC, 0x03, 0x4C, 0xCC, 0x81,
+ // Bytes 30c0 - 30ff
+ 0xE6, 0x03, 0x4C, 0xCC, 0x8C, 0xE6, 0x03, 0x4C,
+ 0xCC, 0xA7, 0xCA, 0x03, 0x4C, 0xCC, 0xAD, 0xDC,
+ 0x03, 0x4C, 0xCC, 0xB1, 0xDC, 0x03, 0x4D, 0xCC,
+ 0x81, 0xE6, 0x03, 0x4D, 0xCC, 0x87, 0xE6, 0x03,
+ 0x4D, 0xCC, 0xA3, 0xDC, 0x03, 0x4E, 0xCC, 0x80,
+ 0xE6, 0x03, 0x4E, 0xCC, 0x81, 0xE6, 0x03, 0x4E,
+ 0xCC, 0x83, 0xE6, 0x03, 0x4E, 0xCC, 0x87, 0xE6,
+ 0x03, 0x4E, 0xCC, 0x8C, 0xE6, 0x03, 0x4E, 0xCC,
+ // Bytes 3100 - 313f
+ 0xA3, 0xDC, 0x03, 0x4E, 0xCC, 0xA7, 0xCA, 0x03,
+ 0x4E, 0xCC, 0xAD, 0xDC, 0x03, 0x4E, 0xCC, 0xB1,
+ 0xDC, 0x03, 0x4F, 0xCC, 0x80, 0xE6, 0x03, 0x4F,
+ 0xCC, 0x81, 0xE6, 0x03, 0x4F, 0xCC, 0x86, 0xE6,
+ 0x03, 0x4F, 0xCC, 0x89, 0xE6, 0x03, 0x4F, 0xCC,
+ 0x8B, 0xE6, 0x03, 0x4F, 0xCC, 0x8C, 0xE6, 0x03,
+ 0x4F, 0xCC, 0x8F, 0xE6, 0x03, 0x4F, 0xCC, 0x91,
+ 0xE6, 0x03, 0x50, 0xCC, 0x81, 0xE6, 0x03, 0x50,
+ // Bytes 3140 - 317f
+ 0xCC, 0x87, 0xE6, 0x03, 0x52, 0xCC, 0x81, 0xE6,
+ 0x03, 0x52, 0xCC, 0x87, 0xE6, 0x03, 0x52, 0xCC,
+ 0x8C, 0xE6, 0x03, 0x52, 0xCC, 0x8F, 0xE6, 0x03,
+ 0x52, 0xCC, 0x91, 0xE6, 0x03, 0x52, 0xCC, 0xA7,
+ 0xCA, 0x03, 0x52, 0xCC, 0xB1, 0xDC, 0x03, 0x53,
+ 0xCC, 0x82, 0xE6, 0x03, 0x53, 0xCC, 0x87, 0xE6,
+ 0x03, 0x53, 0xCC, 0xA6, 0xDC, 0x03, 0x53, 0xCC,
+ 0xA7, 0xCA, 0x03, 0x54, 0xCC, 0x87, 0xE6, 0x03,
+ // Bytes 3180 - 31bf
+ 0x54, 0xCC, 0x8C, 0xE6, 0x03, 0x54, 0xCC, 0xA3,
+ 0xDC, 0x03, 0x54, 0xCC, 0xA6, 0xDC, 0x03, 0x54,
+ 0xCC, 0xA7, 0xCA, 0x03, 0x54, 0xCC, 0xAD, 0xDC,
+ 0x03, 0x54, 0xCC, 0xB1, 0xDC, 0x03, 0x55, 0xCC,
+ 0x80, 0xE6, 0x03, 0x55, 0xCC, 0x81, 0xE6, 0x03,
+ 0x55, 0xCC, 0x82, 0xE6, 0x03, 0x55, 0xCC, 0x86,
+ 0xE6, 0x03, 0x55, 0xCC, 0x89, 0xE6, 0x03, 0x55,
+ 0xCC, 0x8A, 0xE6, 0x03, 0x55, 0xCC, 0x8B, 0xE6,
+ // Bytes 31c0 - 31ff
+ 0x03, 0x55, 0xCC, 0x8C, 0xE6, 0x03, 0x55, 0xCC,
+ 0x8F, 0xE6, 0x03, 0x55, 0xCC, 0x91, 0xE6, 0x03,
+ 0x55, 0xCC, 0xA3, 0xDC, 0x03, 0x55, 0xCC, 0xA4,
+ 0xDC, 0x03, 0x55, 0xCC, 0xA8, 0xCA, 0x03, 0x55,
+ 0xCC, 0xAD, 0xDC, 0x03, 0x55, 0xCC, 0xB0, 0xDC,
+ 0x03, 0x56, 0xCC, 0x83, 0xE6, 0x03, 0x56, 0xCC,
+ 0xA3, 0xDC, 0x03, 0x57, 0xCC, 0x80, 0xE6, 0x03,
+ 0x57, 0xCC, 0x81, 0xE6, 0x03, 0x57, 0xCC, 0x82,
+ // Bytes 3200 - 323f
+ 0xE6, 0x03, 0x57, 0xCC, 0x87, 0xE6, 0x03, 0x57,
+ 0xCC, 0x88, 0xE6, 0x03, 0x57, 0xCC, 0xA3, 0xDC,
+ 0x03, 0x58, 0xCC, 0x87, 0xE6, 0x03, 0x58, 0xCC,
+ 0x88, 0xE6, 0x03, 0x59, 0xCC, 0x80, 0xE6, 0x03,
+ 0x59, 0xCC, 0x81, 0xE6, 0x03, 0x59, 0xCC, 0x82,
+ 0xE6, 0x03, 0x59, 0xCC, 0x83, 0xE6, 0x03, 0x59,
+ 0xCC, 0x84, 0xE6, 0x03, 0x59, 0xCC, 0x87, 0xE6,
+ 0x03, 0x59, 0xCC, 0x88, 0xE6, 0x03, 0x59, 0xCC,
+ // Bytes 3240 - 327f
+ 0x89, 0xE6, 0x03, 0x59, 0xCC, 0xA3, 0xDC, 0x03,
+ 0x5A, 0xCC, 0x81, 0xE6, 0x03, 0x5A, 0xCC, 0x82,
+ 0xE6, 0x03, 0x5A, 0xCC, 0x87, 0xE6, 0x03, 0x5A,
+ 0xCC, 0x8C, 0xE6, 0x03, 0x5A, 0xCC, 0xA3, 0xDC,
+ 0x03, 0x5A, 0xCC, 0xB1, 0xDC, 0x03, 0x61, 0xCC,
+ 0x80, 0xE6, 0x03, 0x61, 0xCC, 0x81, 0xE6, 0x03,
+ 0x61, 0xCC, 0x83, 0xE6, 0x03, 0x61, 0xCC, 0x84,
+ 0xE6, 0x03, 0x61, 0xCC, 0x89, 0xE6, 0x03, 0x61,
+ // Bytes 3280 - 32bf
+ 0xCC, 0x8C, 0xE6, 0x03, 0x61, 0xCC, 0x8F, 0xE6,
+ 0x03, 0x61, 0xCC, 0x91, 0xE6, 0x03, 0x61, 0xCC,
+ 0xA5, 0xDC, 0x03, 0x61, 0xCC, 0xA8, 0xCA, 0x03,
+ 0x62, 0xCC, 0x87, 0xE6, 0x03, 0x62, 0xCC, 0xA3,
+ 0xDC, 0x03, 0x62, 0xCC, 0xB1, 0xDC, 0x03, 0x63,
+ 0xCC, 0x81, 0xE6, 0x03, 0x63, 0xCC, 0x82, 0xE6,
+ 0x03, 0x63, 0xCC, 0x87, 0xE6, 0x03, 0x63, 0xCC,
+ 0x8C, 0xE6, 0x03, 0x64, 0xCC, 0x87, 0xE6, 0x03,
+ // Bytes 32c0 - 32ff
+ 0x64, 0xCC, 0x8C, 0xE6, 0x03, 0x64, 0xCC, 0xA3,
+ 0xDC, 0x03, 0x64, 0xCC, 0xA7, 0xCA, 0x03, 0x64,
+ 0xCC, 0xAD, 0xDC, 0x03, 0x64, 0xCC, 0xB1, 0xDC,
+ 0x03, 0x65, 0xCC, 0x80, 0xE6, 0x03, 0x65, 0xCC,
+ 0x81, 0xE6, 0x03, 0x65, 0xCC, 0x83, 0xE6, 0x03,
+ 0x65, 0xCC, 0x86, 0xE6, 0x03, 0x65, 0xCC, 0x87,
+ 0xE6, 0x03, 0x65, 0xCC, 0x88, 0xE6, 0x03, 0x65,
+ 0xCC, 0x89, 0xE6, 0x03, 0x65, 0xCC, 0x8C, 0xE6,
+ // Bytes 3300 - 333f
+ 0x03, 0x65, 0xCC, 0x8F, 0xE6, 0x03, 0x65, 0xCC,
+ 0x91, 0xE6, 0x03, 0x65, 0xCC, 0xA8, 0xCA, 0x03,
+ 0x65, 0xCC, 0xAD, 0xDC, 0x03, 0x65, 0xCC, 0xB0,
+ 0xDC, 0x03, 0x66, 0xCC, 0x87, 0xE6, 0x03, 0x67,
+ 0xCC, 0x81, 0xE6, 0x03, 0x67, 0xCC, 0x82, 0xE6,
+ 0x03, 0x67, 0xCC, 0x84, 0xE6, 0x03, 0x67, 0xCC,
+ 0x86, 0xE6, 0x03, 0x67, 0xCC, 0x87, 0xE6, 0x03,
+ 0x67, 0xCC, 0x8C, 0xE6, 0x03, 0x67, 0xCC, 0xA7,
+ // Bytes 3340 - 337f
+ 0xCA, 0x03, 0x68, 0xCC, 0x82, 0xE6, 0x03, 0x68,
+ 0xCC, 0x87, 0xE6, 0x03, 0x68, 0xCC, 0x88, 0xE6,
+ 0x03, 0x68, 0xCC, 0x8C, 0xE6, 0x03, 0x68, 0xCC,
+ 0xA3, 0xDC, 0x03, 0x68, 0xCC, 0xA7, 0xCA, 0x03,
+ 0x68, 0xCC, 0xAE, 0xDC, 0x03, 0x68, 0xCC, 0xB1,
+ 0xDC, 0x03, 0x69, 0xCC, 0x80, 0xE6, 0x03, 0x69,
+ 0xCC, 0x81, 0xE6, 0x03, 0x69, 0xCC, 0x82, 0xE6,
+ 0x03, 0x69, 0xCC, 0x83, 0xE6, 0x03, 0x69, 0xCC,
+ // Bytes 3380 - 33bf
+ 0x84, 0xE6, 0x03, 0x69, 0xCC, 0x86, 0xE6, 0x03,
+ 0x69, 0xCC, 0x89, 0xE6, 0x03, 0x69, 0xCC, 0x8C,
+ 0xE6, 0x03, 0x69, 0xCC, 0x8F, 0xE6, 0x03, 0x69,
+ 0xCC, 0x91, 0xE6, 0x03, 0x69, 0xCC, 0xA3, 0xDC,
+ 0x03, 0x69, 0xCC, 0xA8, 0xCA, 0x03, 0x69, 0xCC,
+ 0xB0, 0xDC, 0x03, 0x6A, 0xCC, 0x82, 0xE6, 0x03,
+ 0x6A, 0xCC, 0x8C, 0xE6, 0x03, 0x6B, 0xCC, 0x81,
+ 0xE6, 0x03, 0x6B, 0xCC, 0x8C, 0xE6, 0x03, 0x6B,
+ // Bytes 33c0 - 33ff
+ 0xCC, 0xA3, 0xDC, 0x03, 0x6B, 0xCC, 0xA7, 0xCA,
+ 0x03, 0x6B, 0xCC, 0xB1, 0xDC, 0x03, 0x6C, 0xCC,
+ 0x81, 0xE6, 0x03, 0x6C, 0xCC, 0x8C, 0xE6, 0x03,
+ 0x6C, 0xCC, 0xA7, 0xCA, 0x03, 0x6C, 0xCC, 0xAD,
+ 0xDC, 0x03, 0x6C, 0xCC, 0xB1, 0xDC, 0x03, 0x6D,
+ 0xCC, 0x81, 0xE6, 0x03, 0x6D, 0xCC, 0x87, 0xE6,
+ 0x03, 0x6D, 0xCC, 0xA3, 0xDC, 0x03, 0x6E, 0xCC,
+ 0x80, 0xE6, 0x03, 0x6E, 0xCC, 0x81, 0xE6, 0x03,
+ // Bytes 3400 - 343f
+ 0x6E, 0xCC, 0x83, 0xE6, 0x03, 0x6E, 0xCC, 0x87,
+ 0xE6, 0x03, 0x6E, 0xCC, 0x8C, 0xE6, 0x03, 0x6E,
+ 0xCC, 0xA3, 0xDC, 0x03, 0x6E, 0xCC, 0xA7, 0xCA,
+ 0x03, 0x6E, 0xCC, 0xAD, 0xDC, 0x03, 0x6E, 0xCC,
+ 0xB1, 0xDC, 0x03, 0x6F, 0xCC, 0x80, 0xE6, 0x03,
+ 0x6F, 0xCC, 0x81, 0xE6, 0x03, 0x6F, 0xCC, 0x86,
+ 0xE6, 0x03, 0x6F, 0xCC, 0x89, 0xE6, 0x03, 0x6F,
+ 0xCC, 0x8B, 0xE6, 0x03, 0x6F, 0xCC, 0x8C, 0xE6,
+ // Bytes 3440 - 347f
+ 0x03, 0x6F, 0xCC, 0x8F, 0xE6, 0x03, 0x6F, 0xCC,
+ 0x91, 0xE6, 0x03, 0x70, 0xCC, 0x81, 0xE6, 0x03,
+ 0x70, 0xCC, 0x87, 0xE6, 0x03, 0x72, 0xCC, 0x81,
+ 0xE6, 0x03, 0x72, 0xCC, 0x87, 0xE6, 0x03, 0x72,
+ 0xCC, 0x8C, 0xE6, 0x03, 0x72, 0xCC, 0x8F, 0xE6,
+ 0x03, 0x72, 0xCC, 0x91, 0xE6, 0x03, 0x72, 0xCC,
+ 0xA7, 0xCA, 0x03, 0x72, 0xCC, 0xB1, 0xDC, 0x03,
+ 0x73, 0xCC, 0x82, 0xE6, 0x03, 0x73, 0xCC, 0x87,
+ // Bytes 3480 - 34bf
+ 0xE6, 0x03, 0x73, 0xCC, 0xA6, 0xDC, 0x03, 0x73,
+ 0xCC, 0xA7, 0xCA, 0x03, 0x74, 0xCC, 0x87, 0xE6,
+ 0x03, 0x74, 0xCC, 0x88, 0xE6, 0x03, 0x74, 0xCC,
+ 0x8C, 0xE6, 0x03, 0x74, 0xCC, 0xA3, 0xDC, 0x03,
+ 0x74, 0xCC, 0xA6, 0xDC, 0x03, 0x74, 0xCC, 0xA7,
+ 0xCA, 0x03, 0x74, 0xCC, 0xAD, 0xDC, 0x03, 0x74,
+ 0xCC, 0xB1, 0xDC, 0x03, 0x75, 0xCC, 0x80, 0xE6,
+ 0x03, 0x75, 0xCC, 0x81, 0xE6, 0x03, 0x75, 0xCC,
+ // Bytes 34c0 - 34ff
+ 0x82, 0xE6, 0x03, 0x75, 0xCC, 0x86, 0xE6, 0x03,
+ 0x75, 0xCC, 0x89, 0xE6, 0x03, 0x75, 0xCC, 0x8A,
+ 0xE6, 0x03, 0x75, 0xCC, 0x8B, 0xE6, 0x03, 0x75,
+ 0xCC, 0x8C, 0xE6, 0x03, 0x75, 0xCC, 0x8F, 0xE6,
+ 0x03, 0x75, 0xCC, 0x91, 0xE6, 0x03, 0x75, 0xCC,
+ 0xA3, 0xDC, 0x03, 0x75, 0xCC, 0xA4, 0xDC, 0x03,
+ 0x75, 0xCC, 0xA8, 0xCA, 0x03, 0x75, 0xCC, 0xAD,
+ 0xDC, 0x03, 0x75, 0xCC, 0xB0, 0xDC, 0x03, 0x76,
+ // Bytes 3500 - 353f
+ 0xCC, 0x83, 0xE6, 0x03, 0x76, 0xCC, 0xA3, 0xDC,
+ 0x03, 0x77, 0xCC, 0x80, 0xE6, 0x03, 0x77, 0xCC,
+ 0x81, 0xE6, 0x03, 0x77, 0xCC, 0x82, 0xE6, 0x03,
+ 0x77, 0xCC, 0x87, 0xE6, 0x03, 0x77, 0xCC, 0x88,
+ 0xE6, 0x03, 0x77, 0xCC, 0x8A, 0xE6, 0x03, 0x77,
+ 0xCC, 0xA3, 0xDC, 0x03, 0x78, 0xCC, 0x87, 0xE6,
+ 0x03, 0x78, 0xCC, 0x88, 0xE6, 0x03, 0x79, 0xCC,
+ 0x80, 0xE6, 0x03, 0x79, 0xCC, 0x81, 0xE6, 0x03,
+ // Bytes 3540 - 357f
+ 0x79, 0xCC, 0x82, 0xE6, 0x03, 0x79, 0xCC, 0x83,
+ 0xE6, 0x03, 0x79, 0xCC, 0x84, 0xE6, 0x03, 0x79,
+ 0xCC, 0x87, 0xE6, 0x03, 0x79, 0xCC, 0x88, 0xE6,
+ 0x03, 0x79, 0xCC, 0x89, 0xE6, 0x03, 0x79, 0xCC,
+ 0x8A, 0xE6, 0x03, 0x79, 0xCC, 0xA3, 0xDC, 0x03,
+ 0x7A, 0xCC, 0x81, 0xE6, 0x03, 0x7A, 0xCC, 0x82,
+ 0xE6, 0x03, 0x7A, 0xCC, 0x87, 0xE6, 0x03, 0x7A,
+ 0xCC, 0x8C, 0xE6, 0x03, 0x7A, 0xCC, 0xA3, 0xDC,
+ // Bytes 3580 - 35bf
+ 0x03, 0x7A, 0xCC, 0xB1, 0xDC, 0x04, 0xC2, 0xA8,
+ 0xCC, 0x80, 0xE6, 0x04, 0xC2, 0xA8, 0xCC, 0x81,
+ 0xE6, 0x04, 0xC2, 0xA8, 0xCD, 0x82, 0xE6, 0x04,
+ 0xC3, 0x86, 0xCC, 0x81, 0xE6, 0x04, 0xC3, 0x86,
+ 0xCC, 0x84, 0xE6, 0x04, 0xC3, 0x98, 0xCC, 0x81,
+ 0xE6, 0x04, 0xC3, 0xA6, 0xCC, 0x81, 0xE6, 0x04,
+ 0xC3, 0xA6, 0xCC, 0x84, 0xE6, 0x04, 0xC3, 0xB8,
+ 0xCC, 0x81, 0xE6, 0x04, 0xC5, 0xBF, 0xCC, 0x87,
+ // Bytes 35c0 - 35ff
+ 0xE6, 0x04, 0xC6, 0xB7, 0xCC, 0x8C, 0xE6, 0x04,
+ 0xCA, 0x92, 0xCC, 0x8C, 0xE6, 0x04, 0xCE, 0x91,
+ 0xCC, 0x80, 0xE6, 0x04, 0xCE, 0x91, 0xCC, 0x81,
+ 0xE6, 0x04, 0xCE, 0x91, 0xCC, 0x84, 0xE6, 0x04,
+ 0xCE, 0x91, 0xCC, 0x86, 0xE6, 0x04, 0xCE, 0x91,
+ 0xCD, 0x85, 0xF0, 0x04, 0xCE, 0x95, 0xCC, 0x80,
+ 0xE6, 0x04, 0xCE, 0x95, 0xCC, 0x81, 0xE6, 0x04,
+ 0xCE, 0x97, 0xCC, 0x80, 0xE6, 0x04, 0xCE, 0x97,
+ // Bytes 3600 - 363f
+ 0xCC, 0x81, 0xE6, 0x04, 0xCE, 0x97, 0xCD, 0x85,
+ 0xF0, 0x04, 0xCE, 0x99, 0xCC, 0x80, 0xE6, 0x04,
+ 0xCE, 0x99, 0xCC, 0x81, 0xE6, 0x04, 0xCE, 0x99,
+ 0xCC, 0x84, 0xE6, 0x04, 0xCE, 0x99, 0xCC, 0x86,
+ 0xE6, 0x04, 0xCE, 0x99, 0xCC, 0x88, 0xE6, 0x04,
+ 0xCE, 0x9F, 0xCC, 0x80, 0xE6, 0x04, 0xCE, 0x9F,
+ 0xCC, 0x81, 0xE6, 0x04, 0xCE, 0xA1, 0xCC, 0x94,
+ 0xE6, 0x04, 0xCE, 0xA5, 0xCC, 0x80, 0xE6, 0x04,
+ // Bytes 3640 - 367f
+ 0xCE, 0xA5, 0xCC, 0x81, 0xE6, 0x04, 0xCE, 0xA5,
+ 0xCC, 0x84, 0xE6, 0x04, 0xCE, 0xA5, 0xCC, 0x86,
+ 0xE6, 0x04, 0xCE, 0xA5, 0xCC, 0x88, 0xE6, 0x04,
+ 0xCE, 0xA9, 0xCC, 0x80, 0xE6, 0x04, 0xCE, 0xA9,
+ 0xCC, 0x81, 0xE6, 0x04, 0xCE, 0xA9, 0xCD, 0x85,
+ 0xF0, 0x04, 0xCE, 0xB1, 0xCC, 0x84, 0xE6, 0x04,
+ 0xCE, 0xB1, 0xCC, 0x86, 0xE6, 0x04, 0xCE, 0xB1,
+ 0xCD, 0x85, 0xF0, 0x04, 0xCE, 0xB5, 0xCC, 0x80,
+ // Bytes 3680 - 36bf
+ 0xE6, 0x04, 0xCE, 0xB5, 0xCC, 0x81, 0xE6, 0x04,
+ 0xCE, 0xB7, 0xCD, 0x85, 0xF0, 0x04, 0xCE, 0xB9,
+ 0xCC, 0x80, 0xE6, 0x04, 0xCE, 0xB9, 0xCC, 0x81,
+ 0xE6, 0x04, 0xCE, 0xB9, 0xCC, 0x84, 0xE6, 0x04,
+ 0xCE, 0xB9, 0xCC, 0x86, 0xE6, 0x04, 0xCE, 0xB9,
+ 0xCD, 0x82, 0xE6, 0x04, 0xCE, 0xBF, 0xCC, 0x80,
+ 0xE6, 0x04, 0xCE, 0xBF, 0xCC, 0x81, 0xE6, 0x04,
+ 0xCF, 0x81, 0xCC, 0x93, 0xE6, 0x04, 0xCF, 0x81,
+ // Bytes 36c0 - 36ff
+ 0xCC, 0x94, 0xE6, 0x04, 0xCF, 0x85, 0xCC, 0x80,
+ 0xE6, 0x04, 0xCF, 0x85, 0xCC, 0x81, 0xE6, 0x04,
+ 0xCF, 0x85, 0xCC, 0x84, 0xE6, 0x04, 0xCF, 0x85,
+ 0xCC, 0x86, 0xE6, 0x04, 0xCF, 0x85, 0xCD, 0x82,
+ 0xE6, 0x04, 0xCF, 0x89, 0xCD, 0x85, 0xF0, 0x04,
+ 0xCF, 0x92, 0xCC, 0x81, 0xE6, 0x04, 0xCF, 0x92,
+ 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0x86, 0xCC, 0x88,
+ 0xE6, 0x04, 0xD0, 0x90, 0xCC, 0x86, 0xE6, 0x04,
+ // Bytes 3700 - 373f
+ 0xD0, 0x90, 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0x93,
+ 0xCC, 0x81, 0xE6, 0x04, 0xD0, 0x95, 0xCC, 0x80,
+ 0xE6, 0x04, 0xD0, 0x95, 0xCC, 0x86, 0xE6, 0x04,
+ 0xD0, 0x95, 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0x96,
+ 0xCC, 0x86, 0xE6, 0x04, 0xD0, 0x96, 0xCC, 0x88,
+ 0xE6, 0x04, 0xD0, 0x97, 0xCC, 0x88, 0xE6, 0x04,
+ 0xD0, 0x98, 0xCC, 0x80, 0xE6, 0x04, 0xD0, 0x98,
+ 0xCC, 0x84, 0xE6, 0x04, 0xD0, 0x98, 0xCC, 0x86,
+ // Bytes 3740 - 377f
+ 0xE6, 0x04, 0xD0, 0x98, 0xCC, 0x88, 0xE6, 0x04,
+ 0xD0, 0x9A, 0xCC, 0x81, 0xE6, 0x04, 0xD0, 0x9E,
+ 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0xA3, 0xCC, 0x84,
+ 0xE6, 0x04, 0xD0, 0xA3, 0xCC, 0x86, 0xE6, 0x04,
+ 0xD0, 0xA3, 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0xA3,
+ 0xCC, 0x8B, 0xE6, 0x04, 0xD0, 0xA7, 0xCC, 0x88,
+ 0xE6, 0x04, 0xD0, 0xAB, 0xCC, 0x88, 0xE6, 0x04,
+ 0xD0, 0xAD, 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0xB0,
+ // Bytes 3780 - 37bf
+ 0xCC, 0x86, 0xE6, 0x04, 0xD0, 0xB0, 0xCC, 0x88,
+ 0xE6, 0x04, 0xD0, 0xB3, 0xCC, 0x81, 0xE6, 0x04,
+ 0xD0, 0xB5, 0xCC, 0x80, 0xE6, 0x04, 0xD0, 0xB5,
+ 0xCC, 0x86, 0xE6, 0x04, 0xD0, 0xB5, 0xCC, 0x88,
+ 0xE6, 0x04, 0xD0, 0xB6, 0xCC, 0x86, 0xE6, 0x04,
+ 0xD0, 0xB6, 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0xB7,
+ 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0xB8, 0xCC, 0x80,
+ 0xE6, 0x04, 0xD0, 0xB8, 0xCC, 0x84, 0xE6, 0x04,
+ // Bytes 37c0 - 37ff
+ 0xD0, 0xB8, 0xCC, 0x86, 0xE6, 0x04, 0xD0, 0xB8,
+ 0xCC, 0x88, 0xE6, 0x04, 0xD0, 0xBA, 0xCC, 0x81,
+ 0xE6, 0x04, 0xD0, 0xBE, 0xCC, 0x88, 0xE6, 0x04,
+ 0xD1, 0x83, 0xCC, 0x84, 0xE6, 0x04, 0xD1, 0x83,
+ 0xCC, 0x86, 0xE6, 0x04, 0xD1, 0x83, 0xCC, 0x88,
+ 0xE6, 0x04, 0xD1, 0x83, 0xCC, 0x8B, 0xE6, 0x04,
+ 0xD1, 0x87, 0xCC, 0x88, 0xE6, 0x04, 0xD1, 0x8B,
+ 0xCC, 0x88, 0xE6, 0x04, 0xD1, 0x8D, 0xCC, 0x88,
+ // Bytes 3800 - 383f
+ 0xE6, 0x04, 0xD1, 0x96, 0xCC, 0x88, 0xE6, 0x04,
+ 0xD1, 0xB4, 0xCC, 0x8F, 0xE6, 0x04, 0xD1, 0xB5,
+ 0xCC, 0x8F, 0xE6, 0x04, 0xD3, 0x98, 0xCC, 0x88,
+ 0xE6, 0x04, 0xD3, 0x99, 0xCC, 0x88, 0xE6, 0x04,
+ 0xD3, 0xA8, 0xCC, 0x88, 0xE6, 0x04, 0xD3, 0xA9,
+ 0xCC, 0x88, 0xE6, 0x04, 0xD8, 0xA7, 0xD9, 0x93,
+ 0xE6, 0x04, 0xD8, 0xA7, 0xD9, 0x94, 0xE6, 0x04,
+ 0xD8, 0xA7, 0xD9, 0x95, 0xDC, 0x04, 0xD9, 0x88,
+ // Bytes 3840 - 387f
+ 0xD9, 0x94, 0xE6, 0x04, 0xD9, 0x8A, 0xD9, 0x94,
+ 0xE6, 0x04, 0xDB, 0x81, 0xD9, 0x94, 0xE6, 0x04,
+ 0xDB, 0x92, 0xD9, 0x94, 0xE6, 0x04, 0xDB, 0x95,
+ 0xD9, 0x94, 0xE6, 0x05, 0x41, 0xCC, 0x82, 0xCC,
+ 0x80, 0xE6, 0x05, 0x41, 0xCC, 0x82, 0xCC, 0x81,
+ 0xE6, 0x05, 0x41, 0xCC, 0x82, 0xCC, 0x83, 0xE6,
+ 0x05, 0x41, 0xCC, 0x82, 0xCC, 0x89, 0xE6, 0x05,
+ 0x41, 0xCC, 0x86, 0xCC, 0x80, 0xE6, 0x05, 0x41,
+ // Bytes 3880 - 38bf
+ 0xCC, 0x86, 0xCC, 0x81, 0xE6, 0x05, 0x41, 0xCC,
+ 0x86, 0xCC, 0x83, 0xE6, 0x05, 0x41, 0xCC, 0x86,
+ 0xCC, 0x89, 0xE6, 0x05, 0x41, 0xCC, 0x87, 0xCC,
+ 0x84, 0xE6, 0x05, 0x41, 0xCC, 0x88, 0xCC, 0x84,
+ 0xE6, 0x05, 0x41, 0xCC, 0x8A, 0xCC, 0x81, 0xE6,
+ 0x05, 0x41, 0xCC, 0xA3, 0xCC, 0x82, 0xE6, 0x05,
+ 0x41, 0xCC, 0xA3, 0xCC, 0x86, 0xE6, 0x05, 0x43,
+ 0xCC, 0xA7, 0xCC, 0x81, 0xE6, 0x05, 0x45, 0xCC,
+ // Bytes 38c0 - 38ff
+ 0x82, 0xCC, 0x80, 0xE6, 0x05, 0x45, 0xCC, 0x82,
+ 0xCC, 0x81, 0xE6, 0x05, 0x45, 0xCC, 0x82, 0xCC,
+ 0x83, 0xE6, 0x05, 0x45, 0xCC, 0x82, 0xCC, 0x89,
+ 0xE6, 0x05, 0x45, 0xCC, 0x84, 0xCC, 0x80, 0xE6,
+ 0x05, 0x45, 0xCC, 0x84, 0xCC, 0x81, 0xE6, 0x05,
+ 0x45, 0xCC, 0xA3, 0xCC, 0x82, 0xE6, 0x05, 0x45,
+ 0xCC, 0xA7, 0xCC, 0x86, 0xE6, 0x05, 0x49, 0xCC,
+ 0x88, 0xCC, 0x81, 0xE6, 0x05, 0x4C, 0xCC, 0xA3,
+ // Bytes 3900 - 393f
+ 0xCC, 0x84, 0xE6, 0x05, 0x4F, 0xCC, 0x82, 0xCC,
+ 0x80, 0xE6, 0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x81,
+ 0xE6, 0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x83, 0xE6,
+ 0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x89, 0xE6, 0x05,
+ 0x4F, 0xCC, 0x83, 0xCC, 0x81, 0xE6, 0x05, 0x4F,
+ 0xCC, 0x83, 0xCC, 0x84, 0xE6, 0x05, 0x4F, 0xCC,
+ 0x83, 0xCC, 0x88, 0xE6, 0x05, 0x4F, 0xCC, 0x84,
+ 0xCC, 0x80, 0xE6, 0x05, 0x4F, 0xCC, 0x84, 0xCC,
+ // Bytes 3940 - 397f
+ 0x81, 0xE6, 0x05, 0x4F, 0xCC, 0x87, 0xCC, 0x84,
+ 0xE6, 0x05, 0x4F, 0xCC, 0x88, 0xCC, 0x84, 0xE6,
+ 0x05, 0x4F, 0xCC, 0x9B, 0xCC, 0x80, 0xE6, 0x05,
+ 0x4F, 0xCC, 0x9B, 0xCC, 0x81, 0xE6, 0x05, 0x4F,
+ 0xCC, 0x9B, 0xCC, 0x83, 0xE6, 0x05, 0x4F, 0xCC,
+ 0x9B, 0xCC, 0x89, 0xE6, 0x05, 0x4F, 0xCC, 0x9B,
+ 0xCC, 0xA3, 0xDC, 0x05, 0x4F, 0xCC, 0xA3, 0xCC,
+ 0x82, 0xE6, 0x05, 0x4F, 0xCC, 0xA8, 0xCC, 0x84,
+ // Bytes 3980 - 39bf
+ 0xE6, 0x05, 0x52, 0xCC, 0xA3, 0xCC, 0x84, 0xE6,
+ 0x05, 0x53, 0xCC, 0x81, 0xCC, 0x87, 0xE6, 0x05,
+ 0x53, 0xCC, 0x8C, 0xCC, 0x87, 0xE6, 0x05, 0x53,
+ 0xCC, 0xA3, 0xCC, 0x87, 0xE6, 0x05, 0x55, 0xCC,
+ 0x83, 0xCC, 0x81, 0xE6, 0x05, 0x55, 0xCC, 0x84,
+ 0xCC, 0x88, 0xE6, 0x05, 0x55, 0xCC, 0x88, 0xCC,
+ 0x80, 0xE6, 0x05, 0x55, 0xCC, 0x88, 0xCC, 0x81,
+ 0xE6, 0x05, 0x55, 0xCC, 0x88, 0xCC, 0x84, 0xE6,
+ // Bytes 39c0 - 39ff
+ 0x05, 0x55, 0xCC, 0x88, 0xCC, 0x8C, 0xE6, 0x05,
+ 0x55, 0xCC, 0x9B, 0xCC, 0x80, 0xE6, 0x05, 0x55,
+ 0xCC, 0x9B, 0xCC, 0x81, 0xE6, 0x05, 0x55, 0xCC,
+ 0x9B, 0xCC, 0x83, 0xE6, 0x05, 0x55, 0xCC, 0x9B,
+ 0xCC, 0x89, 0xE6, 0x05, 0x55, 0xCC, 0x9B, 0xCC,
+ 0xA3, 0xDC, 0x05, 0x61, 0xCC, 0x82, 0xCC, 0x80,
+ 0xE6, 0x05, 0x61, 0xCC, 0x82, 0xCC, 0x81, 0xE6,
+ 0x05, 0x61, 0xCC, 0x82, 0xCC, 0x83, 0xE6, 0x05,
+ // Bytes 3a00 - 3a3f
+ 0x61, 0xCC, 0x82, 0xCC, 0x89, 0xE6, 0x05, 0x61,
+ 0xCC, 0x86, 0xCC, 0x80, 0xE6, 0x05, 0x61, 0xCC,
+ 0x86, 0xCC, 0x81, 0xE6, 0x05, 0x61, 0xCC, 0x86,
+ 0xCC, 0x83, 0xE6, 0x05, 0x61, 0xCC, 0x86, 0xCC,
+ 0x89, 0xE6, 0x05, 0x61, 0xCC, 0x87, 0xCC, 0x84,
+ 0xE6, 0x05, 0x61, 0xCC, 0x88, 0xCC, 0x84, 0xE6,
+ 0x05, 0x61, 0xCC, 0x8A, 0xCC, 0x81, 0xE6, 0x05,
+ 0x61, 0xCC, 0xA3, 0xCC, 0x82, 0xE6, 0x05, 0x61,
+ // Bytes 3a40 - 3a7f
+ 0xCC, 0xA3, 0xCC, 0x86, 0xE6, 0x05, 0x63, 0xCC,
+ 0xA7, 0xCC, 0x81, 0xE6, 0x05, 0x65, 0xCC, 0x82,
+ 0xCC, 0x80, 0xE6, 0x05, 0x65, 0xCC, 0x82, 0xCC,
+ 0x81, 0xE6, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x83,
+ 0xE6, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x89, 0xE6,
+ 0x05, 0x65, 0xCC, 0x84, 0xCC, 0x80, 0xE6, 0x05,
+ 0x65, 0xCC, 0x84, 0xCC, 0x81, 0xE6, 0x05, 0x65,
+ 0xCC, 0xA3, 0xCC, 0x82, 0xE6, 0x05, 0x65, 0xCC,
+ // Bytes 3a80 - 3abf
+ 0xA7, 0xCC, 0x86, 0xE6, 0x05, 0x69, 0xCC, 0x88,
+ 0xCC, 0x81, 0xE6, 0x05, 0x6C, 0xCC, 0xA3, 0xCC,
+ 0x84, 0xE6, 0x05, 0x6F, 0xCC, 0x82, 0xCC, 0x80,
+ 0xE6, 0x05, 0x6F, 0xCC, 0x82, 0xCC, 0x81, 0xE6,
+ 0x05, 0x6F, 0xCC, 0x82, 0xCC, 0x83, 0xE6, 0x05,
+ 0x6F, 0xCC, 0x82, 0xCC, 0x89, 0xE6, 0x05, 0x6F,
+ 0xCC, 0x83, 0xCC, 0x81, 0xE6, 0x05, 0x6F, 0xCC,
+ 0x83, 0xCC, 0x84, 0xE6, 0x05, 0x6F, 0xCC, 0x83,
+ // Bytes 3ac0 - 3aff
+ 0xCC, 0x88, 0xE6, 0x05, 0x6F, 0xCC, 0x84, 0xCC,
+ 0x80, 0xE6, 0x05, 0x6F, 0xCC, 0x84, 0xCC, 0x81,
+ 0xE6, 0x05, 0x6F, 0xCC, 0x87, 0xCC, 0x84, 0xE6,
+ 0x05, 0x6F, 0xCC, 0x88, 0xCC, 0x84, 0xE6, 0x05,
+ 0x6F, 0xCC, 0x9B, 0xCC, 0x80, 0xE6, 0x05, 0x6F,
+ 0xCC, 0x9B, 0xCC, 0x81, 0xE6, 0x05, 0x6F, 0xCC,
+ 0x9B, 0xCC, 0x83, 0xE6, 0x05, 0x6F, 0xCC, 0x9B,
+ 0xCC, 0x89, 0xE6, 0x05, 0x6F, 0xCC, 0x9B, 0xCC,
+ // Bytes 3b00 - 3b3f
+ 0xA3, 0xDC, 0x05, 0x6F, 0xCC, 0xA3, 0xCC, 0x82,
+ 0xE6, 0x05, 0x6F, 0xCC, 0xA8, 0xCC, 0x84, 0xE6,
+ 0x05, 0x72, 0xCC, 0xA3, 0xCC, 0x84, 0xE6, 0x05,
+ 0x73, 0xCC, 0x81, 0xCC, 0x87, 0xE6, 0x05, 0x73,
+ 0xCC, 0x8C, 0xCC, 0x87, 0xE6, 0x05, 0x73, 0xCC,
+ 0xA3, 0xCC, 0x87, 0xE6, 0x05, 0x75, 0xCC, 0x83,
+ 0xCC, 0x81, 0xE6, 0x05, 0x75, 0xCC, 0x84, 0xCC,
+ 0x88, 0xE6, 0x05, 0x75, 0xCC, 0x88, 0xCC, 0x80,
+ // Bytes 3b40 - 3b7f
+ 0xE6, 0x05, 0x75, 0xCC, 0x88, 0xCC, 0x81, 0xE6,
+ 0x05, 0x75, 0xCC, 0x88, 0xCC, 0x84, 0xE6, 0x05,
+ 0x75, 0xCC, 0x88, 0xCC, 0x8C, 0xE6, 0x05, 0x75,
+ 0xCC, 0x9B, 0xCC, 0x80, 0xE6, 0x05, 0x75, 0xCC,
+ 0x9B, 0xCC, 0x81, 0xE6, 0x05, 0x75, 0xCC, 0x9B,
+ 0xCC, 0x83, 0xE6, 0x05, 0x75, 0xCC, 0x9B, 0xCC,
+ 0x89, 0xE6, 0x05, 0x75, 0xCC, 0x9B, 0xCC, 0xA3,
+ 0xDC, 0x05, 0xE1, 0xBE, 0xBF, 0xCC, 0x80, 0xE6,
+ // Bytes 3b80 - 3bbf
+ 0x05, 0xE1, 0xBE, 0xBF, 0xCC, 0x81, 0xE6, 0x05,
+ 0xE1, 0xBE, 0xBF, 0xCD, 0x82, 0xE6, 0x05, 0xE1,
+ 0xBF, 0xBE, 0xCC, 0x80, 0xE6, 0x05, 0xE1, 0xBF,
+ 0xBE, 0xCC, 0x81, 0xE6, 0x05, 0xE1, 0xBF, 0xBE,
+ 0xCD, 0x82, 0xE6, 0x05, 0xE2, 0x86, 0x90, 0xCC,
+ 0xB8, 0x01, 0x05, 0xE2, 0x86, 0x92, 0xCC, 0xB8,
+ 0x01, 0x05, 0xE2, 0x86, 0x94, 0xCC, 0xB8, 0x01,
+ 0x05, 0xE2, 0x87, 0x90, 0xCC, 0xB8, 0x01, 0x05,
+ // Bytes 3bc0 - 3bff
+ 0xE2, 0x87, 0x92, 0xCC, 0xB8, 0x01, 0x05, 0xE2,
+ 0x87, 0x94, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x88,
+ 0x83, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x88, 0x88,
+ 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x88, 0x8B, 0xCC,
+ 0xB8, 0x01, 0x05, 0xE2, 0x88, 0xA3, 0xCC, 0xB8,
+ 0x01, 0x05, 0xE2, 0x88, 0xA5, 0xCC, 0xB8, 0x01,
+ 0x05, 0xE2, 0x88, 0xBC, 0xCC, 0xB8, 0x01, 0x05,
+ 0xE2, 0x89, 0x83, 0xCC, 0xB8, 0x01, 0x05, 0xE2,
+ // Bytes 3c00 - 3c3f
+ 0x89, 0x85, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x89,
+ 0x88, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x89, 0x8D,
+ 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x89, 0xA1, 0xCC,
+ 0xB8, 0x01, 0x05, 0xE2, 0x89, 0xA4, 0xCC, 0xB8,
+ 0x01, 0x05, 0xE2, 0x89, 0xA5, 0xCC, 0xB8, 0x01,
+ 0x05, 0xE2, 0x89, 0xB2, 0xCC, 0xB8, 0x01, 0x05,
+ 0xE2, 0x89, 0xB3, 0xCC, 0xB8, 0x01, 0x05, 0xE2,
+ 0x89, 0xB6, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x89,
+ // Bytes 3c40 - 3c7f
+ 0xB7, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x89, 0xBA,
+ 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x89, 0xBB, 0xCC,
+ 0xB8, 0x01, 0x05, 0xE2, 0x89, 0xBC, 0xCC, 0xB8,
+ 0x01, 0x05, 0xE2, 0x89, 0xBD, 0xCC, 0xB8, 0x01,
+ 0x05, 0xE2, 0x8A, 0x82, 0xCC, 0xB8, 0x01, 0x05,
+ 0xE2, 0x8A, 0x83, 0xCC, 0xB8, 0x01, 0x05, 0xE2,
+ 0x8A, 0x86, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x8A,
+ 0x87, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x8A, 0x91,
+ // Bytes 3c80 - 3cbf
+ 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x8A, 0x92, 0xCC,
+ 0xB8, 0x01, 0x05, 0xE2, 0x8A, 0xA2, 0xCC, 0xB8,
+ 0x01, 0x05, 0xE2, 0x8A, 0xA8, 0xCC, 0xB8, 0x01,
+ 0x05, 0xE2, 0x8A, 0xA9, 0xCC, 0xB8, 0x01, 0x05,
+ 0xE2, 0x8A, 0xAB, 0xCC, 0xB8, 0x01, 0x05, 0xE2,
+ 0x8A, 0xB2, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x8A,
+ 0xB3, 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x8A, 0xB4,
+ 0xCC, 0xB8, 0x01, 0x05, 0xE2, 0x8A, 0xB5, 0xCC,
+ // Bytes 3cc0 - 3cff
+ 0xB8, 0x01, 0x06, 0xCE, 0x91, 0xCC, 0x93, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0x91, 0xCC, 0x94, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0x97, 0xCC, 0x93, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0x97, 0xCC, 0x94, 0xCD,
+ // Bytes 3d00 - 3d3f
+ 0x85, 0xF0, 0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCD,
+ 0x82, 0xE6, 0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCD,
+ 0x82, 0xE6, 0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC,
+ // Bytes 3d40 - 3d7f
+ 0x81, 0xE6, 0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCD,
+ 0x82, 0xE6, 0x06, 0xCE, 0xA9, 0xCC, 0x93, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xA9, 0xCC, 0x94, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB1, 0xCC, 0x80, 0xCD,
+ // Bytes 3d80 - 3dbf
+ 0x85, 0xF0, 0x06, 0xCE, 0xB1, 0xCC, 0x81, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB1, 0xCC, 0x93, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB1, 0xCC, 0x94, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB1, 0xCD, 0x82, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC,
+ // Bytes 3dc0 - 3dff
+ 0x81, 0xE6, 0x06, 0xCE, 0xB7, 0xCC, 0x80, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB7, 0xCC, 0x81, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB7, 0xCC, 0x93, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB7, 0xCC, 0x94, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB7, 0xCD, 0x82, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCD,
+ // Bytes 3e00 - 3e3f
+ 0x82, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCD,
+ 0x82, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCD,
+ 0x82, 0xE6, 0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC,
+ // Bytes 3e40 - 3e7f
+ 0x81, 0xE6, 0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCD,
+ 0x82, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCD,
+ // Bytes 3e80 - 3ebf
+ 0x82, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC,
+ 0x80, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCD,
+ 0x82, 0xE6, 0x06, 0xCF, 0x89, 0xCC, 0x80, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCF, 0x89, 0xCC, 0x81, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCF, 0x89, 0xCC, 0x93, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCF, 0x89, 0xCC, 0x94, 0xCD,
+ 0x85, 0xF0, 0x06, 0xCF, 0x89, 0xCD, 0x82, 0xCD,
+ // Bytes 3ec0 - 3eff
+ 0x85, 0xF0, 0x06, 0xE0, 0xA4, 0xA8, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x06, 0xE0, 0xA4, 0xB0, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x06, 0xE0, 0xA4, 0xB3, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x06, 0xE0, 0xB1, 0x86, 0xE0, 0xB1,
+ 0x96, 0x5B, 0x06, 0xE0, 0xB7, 0x99, 0xE0, 0xB7,
+ 0x8A, 0x09, 0x06, 0xE3, 0x81, 0x86, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x8B, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x8D, 0xE3, 0x82,
+ // Bytes 3f00 - 3f3f
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x8F, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x91, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x93, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x95, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x97, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x99, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x9B, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x9D, 0xE3, 0x82,
+ // Bytes 3f40 - 3f7f
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0x9F, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xA1, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xA4, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xA6, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xA8, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82,
+ // Bytes 3f80 - 3fbf
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x82, 0x9D, 0xE3, 0x82,
+ // Bytes 3fc0 - 3fff
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xA6, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xAD, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xAF, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xB1, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xB3, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xB5, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xB7, 0xE3, 0x82,
+ // Bytes 4000 - 403f
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xB9, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xBB, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xBD, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x82, 0xBF, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x81, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x84, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x86, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x88, 0xE3, 0x82,
+ // Bytes 4040 - 407f
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+ // Bytes 4080 - 40bf
+ 0x9A, 0x08, 0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82,
+ 0x9A, 0x08, 0x06, 0xE3, 0x83, 0xAF, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0xB0, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0xB1, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0xB2, 0xE3, 0x82,
+ 0x99, 0x08, 0x06, 0xE3, 0x83, 0xBD, 0xE3, 0x82,
+ 0x99, 0x08, 0x08, 0xCE, 0x91, 0xCC, 0x93, 0xCC,
+ // Bytes 40c0 - 40ff
+ 0x80, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0x91, 0xCC,
+ 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF0, 0x08, 0xCE,
+ 0x91, 0xCC, 0x93, 0xCD, 0x82, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCD,
+ 0x85, 0xF0, 0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCC,
+ 0x81, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0x91, 0xCC,
+ 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF0, 0x08, 0xCE,
+ 0x97, 0xCC, 0x93, 0xCC, 0x80, 0xCD, 0x85, 0xF0,
+ // Bytes 4100 - 413f
+ 0x08, 0xCE, 0x97, 0xCC, 0x93, 0xCC, 0x81, 0xCD,
+ 0x85, 0xF0, 0x08, 0xCE, 0x97, 0xCC, 0x93, 0xCD,
+ 0x82, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0x97, 0xCC,
+ 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF0, 0x08, 0xCE,
+ 0x97, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCE, 0x97, 0xCC, 0x94, 0xCD, 0x82, 0xCD,
+ 0x85, 0xF0, 0x08, 0xCE, 0xA9, 0xCC, 0x93, 0xCC,
+ 0x80, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0xA9, 0xCC,
+ // Bytes 4140 - 417f
+ 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF0, 0x08, 0xCE,
+ 0xA9, 0xCC, 0x93, 0xCD, 0x82, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCD,
+ 0x85, 0xF0, 0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCC,
+ 0x81, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0xA9, 0xCC,
+ 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF0, 0x08, 0xCE,
+ 0xB1, 0xCC, 0x93, 0xCC, 0x80, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCE, 0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCD,
+ // Bytes 4180 - 41bf
+ 0x85, 0xF0, 0x08, 0xCE, 0xB1, 0xCC, 0x93, 0xCD,
+ 0x82, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0xB1, 0xCC,
+ 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF0, 0x08, 0xCE,
+ 0xB1, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCE, 0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCD,
+ 0x85, 0xF0, 0x08, 0xCE, 0xB7, 0xCC, 0x93, 0xCC,
+ 0x80, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0xB7, 0xCC,
+ 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xF0, 0x08, 0xCE,
+ // Bytes 41c0 - 41ff
+ 0xB7, 0xCC, 0x93, 0xCD, 0x82, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xCD,
+ 0x85, 0xF0, 0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCC,
+ 0x81, 0xCD, 0x85, 0xF0, 0x08, 0xCE, 0xB7, 0xCC,
+ 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xF0, 0x08, 0xCF,
+ 0x89, 0xCC, 0x93, 0xCC, 0x80, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCF, 0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCD,
+ 0x85, 0xF0, 0x08, 0xCF, 0x89, 0xCC, 0x93, 0xCD,
+ // Bytes 4200 - 423f
+ 0x82, 0xCD, 0x85, 0xF0, 0x08, 0xCF, 0x89, 0xCC,
+ 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xF0, 0x08, 0xCF,
+ 0x89, 0xCC, 0x94, 0xCC, 0x81, 0xCD, 0x85, 0xF0,
+ 0x08, 0xCF, 0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCD,
+ 0x85, 0xF0, 0x08, 0xF0, 0x91, 0x82, 0x99, 0xF0,
+ 0x91, 0x82, 0xBA, 0x07, 0x08, 0xF0, 0x91, 0x82,
+ 0x9B, 0xF0, 0x91, 0x82, 0xBA, 0x07, 0x08, 0xF0,
+ 0x91, 0x82, 0xA5, 0xF0, 0x91, 0x82, 0xBA, 0x07,
+ // Bytes 4240 - 427f
+ 0x43, 0x20, 0xCC, 0x81, 0xE6, 0x43, 0x20, 0xCC,
+ 0x83, 0xE6, 0x43, 0x20, 0xCC, 0x84, 0xE6, 0x43,
+ 0x20, 0xCC, 0x85, 0xE6, 0x43, 0x20, 0xCC, 0x86,
+ 0xE6, 0x43, 0x20, 0xCC, 0x87, 0xE6, 0x43, 0x20,
+ 0xCC, 0x88, 0xE6, 0x43, 0x20, 0xCC, 0x8A, 0xE6,
+ 0x43, 0x20, 0xCC, 0x8B, 0xE6, 0x43, 0x20, 0xCC,
+ 0x93, 0xE6, 0x43, 0x20, 0xCC, 0x94, 0xE6, 0x43,
+ 0x20, 0xCC, 0xA7, 0xCA, 0x43, 0x20, 0xCC, 0xA8,
+ // Bytes 4280 - 42bf
+ 0xCA, 0x43, 0x20, 0xCC, 0xB3, 0xDC, 0x43, 0x20,
+ 0xCD, 0x82, 0xE6, 0x43, 0x20, 0xCD, 0x85, 0xF0,
+ 0x43, 0x20, 0xD9, 0x8B, 0x1B, 0x43, 0x20, 0xD9,
+ 0x8C, 0x1C, 0x43, 0x20, 0xD9, 0x8D, 0x1D, 0x43,
+ 0x20, 0xD9, 0x8E, 0x1E, 0x43, 0x20, 0xD9, 0x8F,
+ 0x1F, 0x43, 0x20, 0xD9, 0x90, 0x20, 0x43, 0x20,
+ 0xD9, 0x91, 0x21, 0x43, 0x20, 0xD9, 0x92, 0x22,
+ 0x43, 0x41, 0xCC, 0x8A, 0xE6, 0x43, 0x73, 0xCC,
+ // Bytes 42c0 - 42ff
+ 0x87, 0xE6, 0x44, 0x20, 0xE3, 0x82, 0x99, 0x08,
+ 0x44, 0x20, 0xE3, 0x82, 0x9A, 0x08, 0x44, 0xC2,
+ 0xA8, 0xCC, 0x81, 0xE6, 0x44, 0xCE, 0x91, 0xCC,
+ 0x81, 0xE6, 0x44, 0xCE, 0x95, 0xCC, 0x81, 0xE6,
+ 0x44, 0xCE, 0x97, 0xCC, 0x81, 0xE6, 0x44, 0xCE,
+ 0x99, 0xCC, 0x81, 0xE6, 0x44, 0xCE, 0x9F, 0xCC,
+ 0x81, 0xE6, 0x44, 0xCE, 0xA5, 0xCC, 0x81, 0xE6,
+ 0x44, 0xCE, 0xA5, 0xCC, 0x88, 0xE6, 0x44, 0xCE,
+ // Bytes 4300 - 433f
+ 0xA9, 0xCC, 0x81, 0xE6, 0x44, 0xCE, 0xB1, 0xCC,
+ 0x81, 0xE6, 0x44, 0xCE, 0xB5, 0xCC, 0x81, 0xE6,
+ 0x44, 0xCE, 0xB7, 0xCC, 0x81, 0xE6, 0x44, 0xCE,
+ 0xB9, 0xCC, 0x81, 0xE6, 0x44, 0xCE, 0xBF, 0xCC,
+ 0x81, 0xE6, 0x44, 0xCF, 0x85, 0xCC, 0x81, 0xE6,
+ 0x44, 0xCF, 0x89, 0xCC, 0x81, 0xE6, 0x44, 0xD7,
+ 0x90, 0xD6, 0xB7, 0x11, 0x44, 0xD7, 0x90, 0xD6,
+ 0xB8, 0x12, 0x44, 0xD7, 0x90, 0xD6, 0xBC, 0x15,
+ // Bytes 4340 - 437f
+ 0x44, 0xD7, 0x91, 0xD6, 0xBC, 0x15, 0x44, 0xD7,
+ 0x91, 0xD6, 0xBF, 0x17, 0x44, 0xD7, 0x92, 0xD6,
+ 0xBC, 0x15, 0x44, 0xD7, 0x93, 0xD6, 0xBC, 0x15,
+ 0x44, 0xD7, 0x94, 0xD6, 0xBC, 0x15, 0x44, 0xD7,
+ 0x95, 0xD6, 0xB9, 0x13, 0x44, 0xD7, 0x95, 0xD6,
+ 0xBC, 0x15, 0x44, 0xD7, 0x96, 0xD6, 0xBC, 0x15,
+ 0x44, 0xD7, 0x98, 0xD6, 0xBC, 0x15, 0x44, 0xD7,
+ 0x99, 0xD6, 0xB4, 0x0E, 0x44, 0xD7, 0x99, 0xD6,
+ // Bytes 4380 - 43bf
+ 0xBC, 0x15, 0x44, 0xD7, 0x9A, 0xD6, 0xBC, 0x15,
+ 0x44, 0xD7, 0x9B, 0xD6, 0xBC, 0x15, 0x44, 0xD7,
+ 0x9B, 0xD6, 0xBF, 0x17, 0x44, 0xD7, 0x9C, 0xD6,
+ 0xBC, 0x15, 0x44, 0xD7, 0x9E, 0xD6, 0xBC, 0x15,
+ 0x44, 0xD7, 0xA0, 0xD6, 0xBC, 0x15, 0x44, 0xD7,
+ 0xA1, 0xD6, 0xBC, 0x15, 0x44, 0xD7, 0xA3, 0xD6,
+ 0xBC, 0x15, 0x44, 0xD7, 0xA4, 0xD6, 0xBC, 0x15,
+ 0x44, 0xD7, 0xA4, 0xD6, 0xBF, 0x17, 0x44, 0xD7,
+ // Bytes 43c0 - 43ff
+ 0xA6, 0xD6, 0xBC, 0x15, 0x44, 0xD7, 0xA7, 0xD6,
+ 0xBC, 0x15, 0x44, 0xD7, 0xA8, 0xD6, 0xBC, 0x15,
+ 0x44, 0xD7, 0xA9, 0xD6, 0xBC, 0x15, 0x44, 0xD7,
+ 0xA9, 0xD7, 0x81, 0x18, 0x44, 0xD7, 0xA9, 0xD7,
+ 0x82, 0x19, 0x44, 0xD7, 0xAA, 0xD6, 0xBC, 0x15,
+ 0x44, 0xD7, 0xB2, 0xD6, 0xB7, 0x11, 0x44, 0xD8,
+ 0xA7, 0xD9, 0x8B, 0x1B, 0x44, 0xD8, 0xA7, 0xD9,
+ 0x93, 0xE6, 0x44, 0xD8, 0xA7, 0xD9, 0x94, 0xE6,
+ // Bytes 4400 - 443f
+ 0x44, 0xD8, 0xA7, 0xD9, 0x95, 0xDC, 0x44, 0xD8,
+ 0xB0, 0xD9, 0xB0, 0x23, 0x44, 0xD8, 0xB1, 0xD9,
+ 0xB0, 0x23, 0x44, 0xD9, 0x80, 0xD9, 0x8B, 0x1B,
+ 0x44, 0xD9, 0x80, 0xD9, 0x8E, 0x1E, 0x44, 0xD9,
+ 0x80, 0xD9, 0x8F, 0x1F, 0x44, 0xD9, 0x80, 0xD9,
+ 0x90, 0x20, 0x44, 0xD9, 0x80, 0xD9, 0x91, 0x21,
+ 0x44, 0xD9, 0x80, 0xD9, 0x92, 0x22, 0x44, 0xD9,
+ 0x87, 0xD9, 0xB0, 0x23, 0x44, 0xD9, 0x88, 0xD9,
+ // Bytes 4440 - 447f
+ 0x94, 0xE6, 0x44, 0xD9, 0x89, 0xD9, 0xB0, 0x23,
+ 0x44, 0xD9, 0x8A, 0xD9, 0x94, 0xE6, 0x44, 0xDB,
+ 0x92, 0xD9, 0x94, 0xE6, 0x44, 0xDB, 0x95, 0xD9,
+ 0x94, 0xE6, 0x45, 0x20, 0xCC, 0x88, 0xCC, 0x80,
+ 0xE6, 0x45, 0x20, 0xCC, 0x88, 0xCC, 0x81, 0xE6,
+ 0x45, 0x20, 0xCC, 0x88, 0xCD, 0x82, 0xE6, 0x45,
+ 0x20, 0xCC, 0x93, 0xCC, 0x80, 0xE6, 0x45, 0x20,
+ 0xCC, 0x93, 0xCC, 0x81, 0xE6, 0x45, 0x20, 0xCC,
+ // Bytes 4480 - 44bf
+ 0x93, 0xCD, 0x82, 0xE6, 0x45, 0x20, 0xCC, 0x94,
+ 0xCC, 0x80, 0xE6, 0x45, 0x20, 0xCC, 0x94, 0xCC,
+ 0x81, 0xE6, 0x45, 0x20, 0xCC, 0x94, 0xCD, 0x82,
+ 0xE6, 0x45, 0x20, 0xD9, 0x8C, 0xD9, 0x91, 0x21,
+ 0x45, 0x20, 0xD9, 0x8D, 0xD9, 0x91, 0x21, 0x45,
+ 0x20, 0xD9, 0x8E, 0xD9, 0x91, 0x21, 0x45, 0x20,
+ 0xD9, 0x8F, 0xD9, 0x91, 0x21, 0x45, 0x20, 0xD9,
+ 0x90, 0xD9, 0x91, 0x21, 0x45, 0x20, 0xD9, 0x91,
+ // Bytes 44c0 - 44ff
+ 0xD9, 0xB0, 0x23, 0x45, 0xE2, 0xAB, 0x9D, 0xCC,
+ 0xB8, 0x01, 0x46, 0xCE, 0xB9, 0xCC, 0x88, 0xCC,
+ 0x81, 0xE6, 0x46, 0xCF, 0x85, 0xCC, 0x88, 0xCC,
+ 0x81, 0xE6, 0x46, 0xD7, 0xA9, 0xD6, 0xBC, 0xD7,
+ 0x81, 0x18, 0x46, 0xD7, 0xA9, 0xD6, 0xBC, 0xD7,
+ 0x82, 0x19, 0x46, 0xD9, 0x80, 0xD9, 0x8E, 0xD9,
+ 0x91, 0x21, 0x46, 0xD9, 0x80, 0xD9, 0x8F, 0xD9,
+ 0x91, 0x21, 0x46, 0xD9, 0x80, 0xD9, 0x90, 0xD9,
+ // Bytes 4500 - 453f
+ 0x91, 0x21, 0x46, 0xE0, 0xA4, 0x95, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA4, 0x96, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA4, 0x97, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA4, 0x9C, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA4, 0xA1, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA4, 0xA2, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA4, 0xAB, 0xE0, 0xA4,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA4, 0xAF, 0xE0, 0xA4,
+ // Bytes 4540 - 457f
+ 0xBC, 0x07, 0x46, 0xE0, 0xA6, 0xA1, 0xE0, 0xA6,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA6, 0xA2, 0xE0, 0xA6,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA6, 0xAF, 0xE0, 0xA6,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA8, 0x96, 0xE0, 0xA8,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA8, 0x97, 0xE0, 0xA8,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA8, 0x9C, 0xE0, 0xA8,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA8, 0xAB, 0xE0, 0xA8,
+ 0xBC, 0x07, 0x46, 0xE0, 0xA8, 0xB2, 0xE0, 0xA8,
+ // Bytes 4580 - 45bf
+ 0xBC, 0x07, 0x46, 0xE0, 0xA8, 0xB8, 0xE0, 0xA8,
+ 0xBC, 0x07, 0x46, 0xE0, 0xAC, 0xA1, 0xE0, 0xAC,
+ 0xBC, 0x07, 0x46, 0xE0, 0xAC, 0xA2, 0xE0, 0xAC,
+ 0xBC, 0x07, 0x46, 0xE0, 0xBE, 0xB2, 0xE0, 0xBE,
+ 0x80, 0x82, 0x46, 0xE0, 0xBE, 0xB3, 0xE0, 0xBE,
+ 0x80, 0x82, 0x46, 0xE3, 0x83, 0x86, 0xE3, 0x82,
+ 0x99, 0x08, 0x48, 0xF0, 0x9D, 0x85, 0x97, 0xF0,
+ 0x9D, 0x85, 0xA5, 0xD8, 0x48, 0xF0, 0x9D, 0x85,
+ // Bytes 45c0 - 45ff
+ 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xD8, 0x48, 0xF0,
+ 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85, 0xA5, 0xD8,
+ 0x48, 0xF0, 0x9D, 0x86, 0xBA, 0xF0, 0x9D, 0x85,
+ 0xA5, 0xD8, 0x49, 0xE0, 0xBE, 0xB2, 0xE0, 0xBD,
+ 0xB1, 0xE0, 0xBE, 0x80, 0x82, 0x49, 0xE0, 0xBE,
+ 0xB3, 0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x82,
+ 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85,
+ 0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xD8, 0x4C, 0xF0,
+ // Bytes 4600 - 463f
+ 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+ 0x9D, 0x85, 0xAF, 0xD8, 0x4C, 0xF0, 0x9D, 0x85,
+ 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+ 0xB0, 0xD8, 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+ 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xB1, 0xD8,
+ 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85,
+ 0xA5, 0xF0, 0x9D, 0x85, 0xB2, 0xD8, 0x4C, 0xF0,
+ 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+ // Bytes 4640 - 467f
+ 0x9D, 0x85, 0xAE, 0xD8, 0x4C, 0xF0, 0x9D, 0x86,
+ 0xB9, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+ 0xAF, 0xD8, 0x4C, 0xF0, 0x9D, 0x86, 0xBA, 0xF0,
+ 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xD8,
+ 0x4C, 0xF0, 0x9D, 0x86, 0xBA, 0xF0, 0x9D, 0x85,
+ 0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0xD8, 0x83, 0x41,
+ 0xCC, 0x82, 0xE6, 0x83, 0x41, 0xCC, 0x86, 0xE6,
+ 0x83, 0x41, 0xCC, 0x87, 0xE6, 0x83, 0x41, 0xCC,
+ // Bytes 4680 - 46bf
+ 0x88, 0xE6, 0x83, 0x41, 0xCC, 0x8A, 0xE6, 0x83,
+ 0x41, 0xCC, 0xA3, 0xDC, 0x83, 0x43, 0xCC, 0xA7,
+ 0xCA, 0x83, 0x45, 0xCC, 0x82, 0xE6, 0x83, 0x45,
+ 0xCC, 0x84, 0xE6, 0x83, 0x45, 0xCC, 0xA3, 0xDC,
+ 0x83, 0x45, 0xCC, 0xA7, 0xCA, 0x83, 0x49, 0xCC,
+ 0x88, 0xE6, 0x83, 0x4C, 0xCC, 0xA3, 0xDC, 0x83,
+ 0x4F, 0xCC, 0x82, 0xE6, 0x83, 0x4F, 0xCC, 0x83,
+ 0xE6, 0x83, 0x4F, 0xCC, 0x84, 0xE6, 0x83, 0x4F,
+ // Bytes 46c0 - 46ff
+ 0xCC, 0x87, 0xE6, 0x83, 0x4F, 0xCC, 0x88, 0xE6,
+ 0x83, 0x4F, 0xCC, 0x9B, 0xD8, 0x83, 0x4F, 0xCC,
+ 0xA3, 0xDC, 0x83, 0x4F, 0xCC, 0xA8, 0xCA, 0x83,
+ 0x52, 0xCC, 0xA3, 0xDC, 0x83, 0x53, 0xCC, 0x81,
+ 0xE6, 0x83, 0x53, 0xCC, 0x8C, 0xE6, 0x83, 0x53,
+ 0xCC, 0xA3, 0xDC, 0x83, 0x55, 0xCC, 0x83, 0xE6,
+ 0x83, 0x55, 0xCC, 0x84, 0xE6, 0x83, 0x55, 0xCC,
+ 0x88, 0xE6, 0x83, 0x55, 0xCC, 0x9B, 0xD8, 0x83,
+ // Bytes 4700 - 473f
+ 0x61, 0xCC, 0x82, 0xE6, 0x83, 0x61, 0xCC, 0x86,
+ 0xE6, 0x83, 0x61, 0xCC, 0x87, 0xE6, 0x83, 0x61,
+ 0xCC, 0x88, 0xE6, 0x83, 0x61, 0xCC, 0x8A, 0xE6,
+ 0x83, 0x61, 0xCC, 0xA3, 0xDC, 0x83, 0x63, 0xCC,
+ 0xA7, 0xCA, 0x83, 0x65, 0xCC, 0x82, 0xE6, 0x83,
+ 0x65, 0xCC, 0x84, 0xE6, 0x83, 0x65, 0xCC, 0xA3,
+ 0xDC, 0x83, 0x65, 0xCC, 0xA7, 0xCA, 0x83, 0x69,
+ 0xCC, 0x88, 0xE6, 0x83, 0x6C, 0xCC, 0xA3, 0xDC,
+ // Bytes 4740 - 477f
+ 0x83, 0x6F, 0xCC, 0x82, 0xE6, 0x83, 0x6F, 0xCC,
+ 0x83, 0xE6, 0x83, 0x6F, 0xCC, 0x84, 0xE6, 0x83,
+ 0x6F, 0xCC, 0x87, 0xE6, 0x83, 0x6F, 0xCC, 0x88,
+ 0xE6, 0x83, 0x6F, 0xCC, 0x9B, 0xD8, 0x83, 0x6F,
+ 0xCC, 0xA3, 0xDC, 0x83, 0x6F, 0xCC, 0xA8, 0xCA,
+ 0x83, 0x72, 0xCC, 0xA3, 0xDC, 0x83, 0x73, 0xCC,
+ 0x81, 0xE6, 0x83, 0x73, 0xCC, 0x8C, 0xE6, 0x83,
+ 0x73, 0xCC, 0xA3, 0xDC, 0x83, 0x75, 0xCC, 0x83,
+ // Bytes 4780 - 47bf
+ 0xE6, 0x83, 0x75, 0xCC, 0x84, 0xE6, 0x83, 0x75,
+ 0xCC, 0x88, 0xE6, 0x83, 0x75, 0xCC, 0x9B, 0xD8,
+ 0x84, 0xCE, 0x91, 0xCC, 0x93, 0xE6, 0x84, 0xCE,
+ 0x91, 0xCC, 0x94, 0xE6, 0x84, 0xCE, 0x95, 0xCC,
+ 0x93, 0xE6, 0x84, 0xCE, 0x95, 0xCC, 0x94, 0xE6,
+ 0x84, 0xCE, 0x97, 0xCC, 0x93, 0xE6, 0x84, 0xCE,
+ 0x97, 0xCC, 0x94, 0xE6, 0x84, 0xCE, 0x99, 0xCC,
+ 0x93, 0xE6, 0x84, 0xCE, 0x99, 0xCC, 0x94, 0xE6,
+ // Bytes 47c0 - 47ff
+ 0x84, 0xCE, 0x9F, 0xCC, 0x93, 0xE6, 0x84, 0xCE,
+ 0x9F, 0xCC, 0x94, 0xE6, 0x84, 0xCE, 0xA5, 0xCC,
+ 0x94, 0xE6, 0x84, 0xCE, 0xA9, 0xCC, 0x93, 0xE6,
+ 0x84, 0xCE, 0xA9, 0xCC, 0x94, 0xE6, 0x84, 0xCE,
+ 0xB1, 0xCC, 0x80, 0xE6, 0x84, 0xCE, 0xB1, 0xCC,
+ 0x81, 0xE6, 0x84, 0xCE, 0xB1, 0xCC, 0x93, 0xE6,
+ 0x84, 0xCE, 0xB1, 0xCC, 0x94, 0xE6, 0x84, 0xCE,
+ 0xB1, 0xCD, 0x82, 0xE6, 0x84, 0xCE, 0xB5, 0xCC,
+ // Bytes 4800 - 483f
+ 0x93, 0xE6, 0x84, 0xCE, 0xB5, 0xCC, 0x94, 0xE6,
+ 0x84, 0xCE, 0xB7, 0xCC, 0x80, 0xE6, 0x84, 0xCE,
+ 0xB7, 0xCC, 0x81, 0xE6, 0x84, 0xCE, 0xB7, 0xCC,
+ 0x93, 0xE6, 0x84, 0xCE, 0xB7, 0xCC, 0x94, 0xE6,
+ 0x84, 0xCE, 0xB7, 0xCD, 0x82, 0xE6, 0x84, 0xCE,
+ 0xB9, 0xCC, 0x88, 0xE6, 0x84, 0xCE, 0xB9, 0xCC,
+ 0x93, 0xE6, 0x84, 0xCE, 0xB9, 0xCC, 0x94, 0xE6,
+ 0x84, 0xCE, 0xBF, 0xCC, 0x93, 0xE6, 0x84, 0xCE,
+ // Bytes 4840 - 487f
+ 0xBF, 0xCC, 0x94, 0xE6, 0x84, 0xCF, 0x85, 0xCC,
+ 0x88, 0xE6, 0x84, 0xCF, 0x85, 0xCC, 0x93, 0xE6,
+ 0x84, 0xCF, 0x85, 0xCC, 0x94, 0xE6, 0x84, 0xCF,
+ 0x89, 0xCC, 0x80, 0xE6, 0x84, 0xCF, 0x89, 0xCC,
+ 0x81, 0xE6, 0x84, 0xCF, 0x89, 0xCC, 0x93, 0xE6,
+ 0x84, 0xCF, 0x89, 0xCC, 0x94, 0xE6, 0x84, 0xCF,
+ 0x89, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0x91, 0xCC,
+ 0x93, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0x91, 0xCC,
+ // Bytes 4880 - 48bf
+ 0x93, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0x91, 0xCC,
+ 0x93, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0x91, 0xCC,
+ 0x94, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0x91, 0xCC,
+ 0x94, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0x91, 0xCC,
+ 0x94, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0x97, 0xCC,
+ 0x93, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0x97, 0xCC,
+ 0x93, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0x97, 0xCC,
+ 0x93, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0x97, 0xCC,
+ // Bytes 48c0 - 48ff
+ 0x94, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0x97, 0xCC,
+ 0x94, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0x97, 0xCC,
+ 0x94, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0xA9, 0xCC,
+ 0x93, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0xA9, 0xCC,
+ 0x93, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0xA9, 0xCC,
+ 0x93, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0xA9, 0xCC,
+ 0x94, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0xA9, 0xCC,
+ 0x94, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0xA9, 0xCC,
+ // Bytes 4900 - 493f
+ 0x94, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0xB1, 0xCC,
+ 0x93, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0xB1, 0xCC,
+ 0x93, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0xB1, 0xCC,
+ 0x93, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0xB1, 0xCC,
+ 0x94, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0xB1, 0xCC,
+ 0x94, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0xB1, 0xCC,
+ 0x94, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0xB7, 0xCC,
+ 0x93, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0xB7, 0xCC,
+ // Bytes 4940 - 497f
+ 0x93, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0xB7, 0xCC,
+ 0x93, 0xCD, 0x82, 0xE6, 0x86, 0xCE, 0xB7, 0xCC,
+ 0x94, 0xCC, 0x80, 0xE6, 0x86, 0xCE, 0xB7, 0xCC,
+ 0x94, 0xCC, 0x81, 0xE6, 0x86, 0xCE, 0xB7, 0xCC,
+ 0x94, 0xCD, 0x82, 0xE6, 0x86, 0xCF, 0x89, 0xCC,
+ 0x93, 0xCC, 0x80, 0xE6, 0x86, 0xCF, 0x89, 0xCC,
+ 0x93, 0xCC, 0x81, 0xE6, 0x86, 0xCF, 0x89, 0xCC,
+ 0x93, 0xCD, 0x82, 0xE6, 0x86, 0xCF, 0x89, 0xCC,
+ // Bytes 4980 - 49bf
+ 0x94, 0xCC, 0x80, 0xE6, 0x86, 0xCF, 0x89, 0xCC,
+ 0x94, 0xCC, 0x81, 0xE6, 0x86, 0xCF, 0x89, 0xCC,
+ 0x94, 0xCD, 0x82, 0xE6, 0x42, 0xCC, 0x80, 0xE6,
+ 0xE6, 0x42, 0xCC, 0x81, 0xE6, 0xE6, 0x42, 0xCC,
+ 0x93, 0xE6, 0xE6, 0x44, 0xCC, 0x88, 0xCC, 0x81,
+ 0xE6, 0xE6, 0x43, 0xE3, 0x82, 0x99, 0x08, 0x08,
+ 0x43, 0xE3, 0x82, 0x9A, 0x08, 0x08, 0x46, 0xE0,
+ 0xBD, 0xB1, 0xE0, 0xBD, 0xB2, 0x82, 0x81, 0x46,
+ // Bytes 49c0 - 49ff
+ 0xE0, 0xBD, 0xB1, 0xE0, 0xBD, 0xB4, 0x84, 0x81,
+ 0x46, 0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x82,
+ 0x81,
+}
+
+// nfcValues: 2944 entries, 5888 bytes
+// Block 2 is the null block.
+var nfcValues = [2944]uint16{
+ // Block 0x0, offset 0x0
+ 0x003c: 0x8800, 0x003d: 0x8800, 0x003e: 0x8800,
+ // Block 0x1, offset 0x40
+ 0x0041: 0x8800, 0x0042: 0x8800, 0x0043: 0x8800, 0x0044: 0x8800, 0x0045: 0x8800,
+ 0x0046: 0x8800, 0x0047: 0x8800, 0x0048: 0x8800, 0x0049: 0x8800, 0x004a: 0x8800, 0x004b: 0x8800,
+ 0x004c: 0x8800, 0x004d: 0x8800, 0x004e: 0x8800, 0x004f: 0x8800, 0x0050: 0x8800,
+ 0x0052: 0x8800, 0x0053: 0x8800, 0x0054: 0x8800, 0x0055: 0x8800, 0x0056: 0x8800, 0x0057: 0x8800,
+ 0x0058: 0x8800, 0x0059: 0x8800, 0x005a: 0x8800,
+ 0x0061: 0x8800, 0x0062: 0x8800, 0x0063: 0x8800,
+ 0x0064: 0x8800, 0x0065: 0x8800, 0x0066: 0x8800, 0x0067: 0x8800, 0x0068: 0x8800, 0x0069: 0x8800,
+ 0x006a: 0x8800, 0x006b: 0x8800, 0x006c: 0x8800, 0x006d: 0x8800, 0x006e: 0x8800, 0x006f: 0x8800,
+ 0x0070: 0x8800, 0x0072: 0x8800, 0x0073: 0x8800, 0x0074: 0x8800, 0x0075: 0x8800,
+ 0x0076: 0x8800, 0x0077: 0x8800, 0x0078: 0x8800, 0x0079: 0x8800, 0x007a: 0x8800,
+ // Block 0x2, offset 0x80
+ // Block 0x3, offset 0xc0
+ 0x00c0: 0x2f59, 0x00c1: 0x2f5e, 0x00c2: 0x466e, 0x00c3: 0x2f63, 0x00c4: 0x467d, 0x00c5: 0x4682,
+ 0x00c6: 0x8800, 0x00c7: 0x468c, 0x00c8: 0x2fcc, 0x00c9: 0x2fd1, 0x00ca: 0x4691, 0x00cb: 0x2fe5,
+ 0x00cc: 0x3058, 0x00cd: 0x305d, 0x00ce: 0x3062, 0x00cf: 0x46a5, 0x00d1: 0x30ee,
+ 0x00d2: 0x3111, 0x00d3: 0x3116, 0x00d4: 0x46af, 0x00d5: 0x46b4, 0x00d6: 0x46c3,
+ 0x00d8: 0x8800, 0x00d9: 0x319d, 0x00da: 0x31a2, 0x00db: 0x31a7, 0x00dc: 0x46f5, 0x00dd: 0x321f,
+ 0x00e0: 0x3265, 0x00e1: 0x326a, 0x00e2: 0x46ff, 0x00e3: 0x326f,
+ 0x00e4: 0x470e, 0x00e5: 0x4713, 0x00e6: 0x8800, 0x00e7: 0x471d, 0x00e8: 0x32d8, 0x00e9: 0x32dd,
+ 0x00ea: 0x4722, 0x00eb: 0x32f1, 0x00ec: 0x3369, 0x00ed: 0x336e, 0x00ee: 0x3373, 0x00ef: 0x4736,
+ 0x00f1: 0x33ff, 0x00f2: 0x3422, 0x00f3: 0x3427, 0x00f4: 0x4740, 0x00f5: 0x4745,
+ 0x00f6: 0x4754, 0x00f8: 0x8800, 0x00f9: 0x34b3, 0x00fa: 0x34b8, 0x00fb: 0x34bd,
+ 0x00fc: 0x4786, 0x00fd: 0x353a, 0x00ff: 0x3553,
+ // Block 0x4, offset 0x100
+ 0x0100: 0x2f68, 0x0101: 0x3274, 0x0102: 0x4673, 0x0103: 0x4704, 0x0104: 0x2f86, 0x0105: 0x3292,
+ 0x0106: 0x2f9a, 0x0107: 0x32a6, 0x0108: 0x2f9f, 0x0109: 0x32ab, 0x010a: 0x2fa4, 0x010b: 0x32b0,
+ 0x010c: 0x2fa9, 0x010d: 0x32b5, 0x010e: 0x2fb3, 0x010f: 0x32bf,
+ 0x0112: 0x4696, 0x0113: 0x4727, 0x0114: 0x2fdb, 0x0115: 0x32e7, 0x0116: 0x2fe0, 0x0117: 0x32ec,
+ 0x0118: 0x2ffe, 0x0119: 0x330a, 0x011a: 0x2fef, 0x011b: 0x32fb, 0x011c: 0x3017, 0x011d: 0x3323,
+ 0x011e: 0x3021, 0x011f: 0x332d, 0x0120: 0x3026, 0x0121: 0x3332, 0x0122: 0x3030, 0x0123: 0x333c,
+ 0x0124: 0x3035, 0x0125: 0x3341, 0x0128: 0x3067, 0x0129: 0x3378,
+ 0x012a: 0x306c, 0x012b: 0x337d, 0x012c: 0x3071, 0x012d: 0x3382, 0x012e: 0x3094, 0x012f: 0x33a0,
+ 0x0130: 0x3076, 0x0134: 0x309e, 0x0135: 0x33aa,
+ 0x0136: 0x30b2, 0x0137: 0x33c3, 0x0139: 0x30bc, 0x013a: 0x33cd, 0x013b: 0x30c6,
+ 0x013c: 0x33d7, 0x013d: 0x30c1, 0x013e: 0x33d2,
+ // Block 0x5, offset 0x140
+ 0x0143: 0x30e9, 0x0144: 0x33fa, 0x0145: 0x3102,
+ 0x0146: 0x3413, 0x0147: 0x30f8, 0x0148: 0x3409,
+ 0x014c: 0x46b9, 0x014d: 0x474a, 0x014e: 0x311b, 0x014f: 0x342c, 0x0150: 0x3125, 0x0151: 0x3436,
+ 0x0154: 0x3143, 0x0155: 0x3454, 0x0156: 0x315c, 0x0157: 0x346d,
+ 0x0158: 0x314d, 0x0159: 0x345e, 0x015a: 0x46dc, 0x015b: 0x476d, 0x015c: 0x3166, 0x015d: 0x3477,
+ 0x015e: 0x3175, 0x015f: 0x3486, 0x0160: 0x46e1, 0x0161: 0x4772, 0x0162: 0x318e, 0x0163: 0x34a4,
+ 0x0164: 0x317f, 0x0165: 0x3495, 0x0168: 0x46eb, 0x0169: 0x477c,
+ 0x016a: 0x46f0, 0x016b: 0x4781, 0x016c: 0x31ac, 0x016d: 0x34c2, 0x016e: 0x31b6, 0x016f: 0x34cc,
+ 0x0170: 0x31bb, 0x0171: 0x34d1, 0x0172: 0x31d9, 0x0173: 0x34ef, 0x0174: 0x31fc, 0x0175: 0x3512,
+ 0x0176: 0x3224, 0x0177: 0x353f, 0x0178: 0x3238, 0x0179: 0x3247, 0x017a: 0x3567, 0x017b: 0x3251,
+ 0x017c: 0x3571, 0x017d: 0x3256, 0x017e: 0x3576, 0x017f: 0x8800,
+ // Block 0x6, offset 0x180
+ 0x018d: 0x2f72, 0x018e: 0x327e, 0x018f: 0x3080, 0x0190: 0x338c, 0x0191: 0x312a,
+ 0x0192: 0x343b, 0x0193: 0x31c0, 0x0194: 0x34d6, 0x0195: 0x39b9, 0x0196: 0x3b48, 0x0197: 0x39b2,
+ 0x0198: 0x3b41, 0x0199: 0x39c0, 0x019a: 0x3b4f, 0x019b: 0x39ab, 0x019c: 0x3b3a,
+ 0x019e: 0x389a, 0x019f: 0x3a29, 0x01a0: 0x3893, 0x01a1: 0x3a22, 0x01a2: 0x359d, 0x01a3: 0x35af,
+ 0x01a6: 0x302b, 0x01a7: 0x3337, 0x01a8: 0x30a8, 0x01a9: 0x33b9,
+ 0x01aa: 0x46d2, 0x01ab: 0x4763, 0x01ac: 0x397a, 0x01ad: 0x3b09, 0x01ae: 0x35c1, 0x01af: 0x35c7,
+ 0x01b0: 0x33af, 0x01b4: 0x3012, 0x01b5: 0x331e,
+ 0x01b8: 0x30e4, 0x01b9: 0x33f5, 0x01ba: 0x38a1, 0x01bb: 0x3a30,
+ 0x01bc: 0x3597, 0x01bd: 0x35a9, 0x01be: 0x35a3, 0x01bf: 0x35b5,
+ // Block 0x7, offset 0x1c0
+ 0x01c0: 0x2f77, 0x01c1: 0x3283, 0x01c2: 0x2f7c, 0x01c3: 0x3288, 0x01c4: 0x2ff4, 0x01c5: 0x3300,
+ 0x01c6: 0x2ff9, 0x01c7: 0x3305, 0x01c8: 0x3085, 0x01c9: 0x3391, 0x01ca: 0x308a, 0x01cb: 0x3396,
+ 0x01cc: 0x312f, 0x01cd: 0x3440, 0x01ce: 0x3134, 0x01cf: 0x3445, 0x01d0: 0x3152, 0x01d1: 0x3463,
+ 0x01d2: 0x3157, 0x01d3: 0x3468, 0x01d4: 0x31c5, 0x01d5: 0x34db, 0x01d6: 0x31ca, 0x01d7: 0x34e0,
+ 0x01d8: 0x3170, 0x01d9: 0x3481, 0x01da: 0x3189, 0x01db: 0x349f,
+ 0x01de: 0x3044, 0x01df: 0x3350,
+ 0x01e6: 0x4678, 0x01e7: 0x4709, 0x01e8: 0x46a0, 0x01e9: 0x4731,
+ 0x01ea: 0x3949, 0x01eb: 0x3ad8, 0x01ec: 0x3926, 0x01ed: 0x3ab5, 0x01ee: 0x46be, 0x01ef: 0x474f,
+ 0x01f0: 0x3942, 0x01f1: 0x3ad1, 0x01f2: 0x322e, 0x01f3: 0x3549,
+ // Block 0x8, offset 0x200
+ 0x0200: 0x86e6, 0x0201: 0x86e6, 0x0202: 0x86e6, 0x0203: 0x86e6, 0x0204: 0x86e6, 0x0205: 0x80e6,
+ 0x0206: 0x86e6, 0x0207: 0x86e6, 0x0208: 0x86e6, 0x0209: 0x86e6, 0x020a: 0x86e6, 0x020b: 0x86e6,
+ 0x020c: 0x86e6, 0x020d: 0x80e6, 0x020e: 0x80e6, 0x020f: 0x86e6, 0x0210: 0x80e6, 0x0211: 0x86e6,
+ 0x0212: 0x80e6, 0x0213: 0x86e6, 0x0214: 0x86e6, 0x0215: 0x80e8, 0x0216: 0x80dc, 0x0217: 0x80dc,
+ 0x0218: 0x80dc, 0x0219: 0x80dc, 0x021a: 0x80e8, 0x021b: 0x86d8, 0x021c: 0x80dc, 0x021d: 0x80dc,
+ 0x021e: 0x80dc, 0x021f: 0x80dc, 0x0220: 0x80dc, 0x0221: 0x80ca, 0x0222: 0x80ca, 0x0223: 0x86dc,
+ 0x0224: 0x86dc, 0x0225: 0x86dc, 0x0226: 0x86dc, 0x0227: 0x86ca, 0x0228: 0x86ca, 0x0229: 0x80dc,
+ 0x022a: 0x80dc, 0x022b: 0x80dc, 0x022c: 0x80dc, 0x022d: 0x86dc, 0x022e: 0x86dc, 0x022f: 0x80dc,
+ 0x0230: 0x86dc, 0x0231: 0x86dc, 0x0232: 0x80dc, 0x0233: 0x80dc, 0x0234: 0x8001, 0x0235: 0x8001,
+ 0x0236: 0x8001, 0x0237: 0x8001, 0x0238: 0x8601, 0x0239: 0x80dc, 0x023a: 0x80dc, 0x023b: 0x80dc,
+ 0x023c: 0x80dc, 0x023d: 0x80e6, 0x023e: 0x80e6, 0x023f: 0x80e6,
+ // Block 0x9, offset 0x240
+ 0x0240: 0x4994, 0x0241: 0x4999, 0x0242: 0x86e6, 0x0243: 0x499e, 0x0244: 0x49a3, 0x0245: 0x86f0,
+ 0x0246: 0x80e6, 0x0247: 0x80dc, 0x0248: 0x80dc, 0x0249: 0x80dc, 0x024a: 0x80e6, 0x024b: 0x80e6,
+ 0x024c: 0x80e6, 0x024d: 0x80dc, 0x024e: 0x80dc, 0x0250: 0x80e6, 0x0251: 0x80e6,
+ 0x0252: 0x80e6, 0x0253: 0x80dc, 0x0254: 0x80dc, 0x0255: 0x80dc, 0x0256: 0x80dc, 0x0257: 0x80e6,
+ 0x0258: 0x80e8, 0x0259: 0x80dc, 0x025a: 0x80dc, 0x025b: 0x80e6, 0x025c: 0x80e9, 0x025d: 0x80ea,
+ 0x025e: 0x80ea, 0x025f: 0x80e9, 0x0260: 0x80ea, 0x0261: 0x80ea, 0x0262: 0x80e9, 0x0263: 0x80e6,
+ 0x0264: 0x80e6, 0x0265: 0x80e6, 0x0266: 0x80e6, 0x0267: 0x80e6, 0x0268: 0x80e6, 0x0269: 0x80e6,
+ 0x026a: 0x80e6, 0x026b: 0x80e6, 0x026c: 0x80e6, 0x026d: 0x80e6, 0x026e: 0x80e6, 0x026f: 0x80e6,
+ 0x0274: 0x0170,
+ 0x027e: 0x0037,
+ // Block 0xa, offset 0x280
+ 0x0285: 0x358b,
+ 0x0286: 0x35d3, 0x0287: 0x00d1, 0x0288: 0x35f1, 0x0289: 0x35fd, 0x028a: 0x360f,
+ 0x028c: 0x362d, 0x028e: 0x363f, 0x028f: 0x365d, 0x0290: 0x3df2, 0x0291: 0x8800,
+ 0x0295: 0x8800, 0x0297: 0x8800,
+ 0x0299: 0x8800,
+ 0x029f: 0x8800, 0x02a1: 0x8800,
+ 0x02a5: 0x8800, 0x02a9: 0x8800,
+ 0x02aa: 0x3621, 0x02ab: 0x3651, 0x02ac: 0x47e4, 0x02ad: 0x3681, 0x02ae: 0x480e, 0x02af: 0x3693,
+ 0x02b0: 0x3e5a, 0x02b1: 0x8800, 0x02b5: 0x8800,
+ 0x02b7: 0x8800, 0x02b9: 0x8800,
+ 0x02bf: 0x8800,
+ // Block 0xb, offset 0x2c0
+ 0x02c0: 0x370b, 0x02c1: 0x3717, 0x02c3: 0x3705,
+ 0x02c6: 0x8800, 0x02c7: 0x36f3,
+ 0x02cc: 0x3747, 0x02cd: 0x372f, 0x02ce: 0x3759, 0x02d0: 0x8800,
+ 0x02d3: 0x8800, 0x02d5: 0x8800, 0x02d6: 0x8800, 0x02d7: 0x8800,
+ 0x02d8: 0x8800, 0x02d9: 0x373b, 0x02da: 0x8800,
+ 0x02de: 0x8800, 0x02e3: 0x8800,
+ 0x02e7: 0x8800,
+ 0x02eb: 0x8800, 0x02ed: 0x8800,
+ 0x02f0: 0x8800, 0x02f3: 0x8800, 0x02f5: 0x8800,
+ 0x02f6: 0x8800, 0x02f7: 0x8800, 0x02f8: 0x8800, 0x02f9: 0x37bf, 0x02fa: 0x8800,
+ 0x02fe: 0x8800,
+ // Block 0xc, offset 0x300
+ 0x0301: 0x371d, 0x0302: 0x37a1,
+ 0x0310: 0x36f9, 0x0311: 0x377d,
+ 0x0312: 0x36ff, 0x0313: 0x3783, 0x0316: 0x3711, 0x0317: 0x3795,
+ 0x0318: 0x8800, 0x0319: 0x8800, 0x031a: 0x3813, 0x031b: 0x3819, 0x031c: 0x3723, 0x031d: 0x37a7,
+ 0x031e: 0x3729, 0x031f: 0x37ad, 0x0322: 0x3735, 0x0323: 0x37b9,
+ 0x0324: 0x3741, 0x0325: 0x37c5, 0x0326: 0x374d, 0x0327: 0x37d1, 0x0328: 0x8800, 0x0329: 0x8800,
+ 0x032a: 0x381f, 0x032b: 0x3825, 0x032c: 0x3777, 0x032d: 0x37fb, 0x032e: 0x3753, 0x032f: 0x37d7,
+ 0x0330: 0x375f, 0x0331: 0x37e3, 0x0332: 0x3765, 0x0333: 0x37e9, 0x0334: 0x376b, 0x0335: 0x37ef,
+ 0x0338: 0x3771, 0x0339: 0x37f5,
+ // Block 0xd, offset 0x340
+ 0x0351: 0x80dc,
+ 0x0352: 0x80e6, 0x0353: 0x80e6, 0x0354: 0x80e6, 0x0355: 0x80e6, 0x0356: 0x80dc, 0x0357: 0x80e6,
+ 0x0358: 0x80e6, 0x0359: 0x80e6, 0x035a: 0x80de, 0x035b: 0x80dc, 0x035c: 0x80e6, 0x035d: 0x80e6,
+ 0x035e: 0x80e6, 0x035f: 0x80e6, 0x0360: 0x80e6, 0x0361: 0x80e6, 0x0362: 0x80dc, 0x0363: 0x80dc,
+ 0x0364: 0x80dc, 0x0365: 0x80dc, 0x0366: 0x80dc, 0x0367: 0x80dc, 0x0368: 0x80e6, 0x0369: 0x80e6,
+ 0x036a: 0x80dc, 0x036b: 0x80e6, 0x036c: 0x80e6, 0x036d: 0x80de, 0x036e: 0x80e4, 0x036f: 0x80e6,
+ 0x0370: 0x800a, 0x0371: 0x800b, 0x0372: 0x800c, 0x0373: 0x800d, 0x0374: 0x800e, 0x0375: 0x800f,
+ 0x0376: 0x8010, 0x0377: 0x8011, 0x0378: 0x8012, 0x0379: 0x8013, 0x037a: 0x8013, 0x037b: 0x8014,
+ 0x037c: 0x8015, 0x037d: 0x8016, 0x037f: 0x8017,
+ // Block 0xe, offset 0x380
+ 0x0388: 0x8800, 0x038a: 0x8800, 0x038b: 0x801b,
+ 0x038c: 0x801c, 0x038d: 0x801d, 0x038e: 0x801e, 0x038f: 0x801f, 0x0390: 0x8020, 0x0391: 0x8021,
+ 0x0392: 0x8022, 0x0393: 0x86e6, 0x0394: 0x86e6, 0x0395: 0x86dc, 0x0396: 0x80dc, 0x0397: 0x80e6,
+ 0x0398: 0x80e6, 0x0399: 0x80e6, 0x039a: 0x80e6, 0x039b: 0x80e6, 0x039c: 0x80dc, 0x039d: 0x80e6,
+ 0x039e: 0x80e6, 0x039f: 0x80dc,
+ 0x03b0: 0x8023,
+ // Block 0xf, offset 0x3c0
+ 0x03c5: 0x8800,
+ 0x03c6: 0x1946, 0x03c7: 0x8800, 0x03c8: 0x194d, 0x03c9: 0x8800, 0x03ca: 0x1954, 0x03cb: 0x8800,
+ 0x03cc: 0x195b, 0x03cd: 0x8800, 0x03ce: 0x1962, 0x03d1: 0x8800,
+ 0x03d2: 0x1969,
+ 0x03f4: 0x8007, 0x03f5: 0x8600,
+ 0x03fa: 0x8800, 0x03fb: 0x1970,
+ 0x03fc: 0x8800, 0x03fd: 0x1977, 0x03fe: 0x8800, 0x03ff: 0x8800,
+ // Block 0x10, offset 0x400
+ 0x0400: 0x2f81, 0x0401: 0x328d, 0x0402: 0x2f8b, 0x0403: 0x3297, 0x0404: 0x2f90, 0x0405: 0x329c,
+ 0x0406: 0x2f95, 0x0407: 0x32a1, 0x0408: 0x38b6, 0x0409: 0x3a45, 0x040a: 0x2fae, 0x040b: 0x32ba,
+ 0x040c: 0x2fb8, 0x040d: 0x32c4, 0x040e: 0x2fc7, 0x040f: 0x32d3, 0x0410: 0x2fbd, 0x0411: 0x32c9,
+ 0x0412: 0x2fc2, 0x0413: 0x32ce, 0x0414: 0x38d9, 0x0415: 0x3a68, 0x0416: 0x38e0, 0x0417: 0x3a6f,
+ 0x0418: 0x3003, 0x0419: 0x330f, 0x041a: 0x3008, 0x041b: 0x3314, 0x041c: 0x38ee, 0x041d: 0x3a7d,
+ 0x041e: 0x300d, 0x041f: 0x3319, 0x0420: 0x301c, 0x0421: 0x3328, 0x0422: 0x303a, 0x0423: 0x3346,
+ 0x0424: 0x3049, 0x0425: 0x3355, 0x0426: 0x303f, 0x0427: 0x334b, 0x0428: 0x304e, 0x0429: 0x335a,
+ 0x042a: 0x3053, 0x042b: 0x335f, 0x042c: 0x3099, 0x042d: 0x33a5, 0x042e: 0x38f5, 0x042f: 0x3a84,
+ 0x0430: 0x30a3, 0x0431: 0x33b4, 0x0432: 0x30ad, 0x0433: 0x33be, 0x0434: 0x30b7, 0x0435: 0x33c8,
+ 0x0436: 0x46aa, 0x0437: 0x473b, 0x0438: 0x38fc, 0x0439: 0x3a8b, 0x043a: 0x30d0, 0x043b: 0x33e1,
+ 0x043c: 0x30cb, 0x043d: 0x33dc, 0x043e: 0x30d5, 0x043f: 0x33e6,
+ // Block 0x11, offset 0x440
+ 0x0440: 0x30da, 0x0441: 0x33eb, 0x0442: 0x30df, 0x0443: 0x33f0, 0x0444: 0x30f3, 0x0445: 0x3404,
+ 0x0446: 0x30fd, 0x0447: 0x340e, 0x0448: 0x310c, 0x0449: 0x341d, 0x044a: 0x3107, 0x044b: 0x3418,
+ 0x044c: 0x391f, 0x044d: 0x3aae, 0x044e: 0x392d, 0x044f: 0x3abc, 0x0450: 0x3934, 0x0451: 0x3ac3,
+ 0x0452: 0x393b, 0x0453: 0x3aca, 0x0454: 0x3139, 0x0455: 0x344a, 0x0456: 0x313e, 0x0457: 0x344f,
+ 0x0458: 0x3148, 0x0459: 0x3459, 0x045a: 0x46d7, 0x045b: 0x4768, 0x045c: 0x3981, 0x045d: 0x3b10,
+ 0x045e: 0x3161, 0x045f: 0x3472, 0x0460: 0x316b, 0x0461: 0x347c, 0x0462: 0x46e6, 0x0463: 0x4777,
+ 0x0464: 0x3988, 0x0465: 0x3b17, 0x0466: 0x398f, 0x0467: 0x3b1e, 0x0468: 0x3996, 0x0469: 0x3b25,
+ 0x046a: 0x317a, 0x046b: 0x348b, 0x046c: 0x3184, 0x046d: 0x349a, 0x046e: 0x3198, 0x046f: 0x34ae,
+ 0x0470: 0x3193, 0x0471: 0x34a9, 0x0472: 0x31d4, 0x0473: 0x34ea, 0x0474: 0x31e3, 0x0475: 0x34f9,
+ 0x0476: 0x31de, 0x0477: 0x34f4, 0x0478: 0x399d, 0x0479: 0x3b2c, 0x047a: 0x39a4, 0x047b: 0x3b33,
+ 0x047c: 0x31e8, 0x047d: 0x34fe, 0x047e: 0x31ed, 0x047f: 0x3503,
+ // Block 0x12, offset 0x480
+ 0x0480: 0x31f2, 0x0481: 0x3508, 0x0482: 0x31f7, 0x0483: 0x350d, 0x0484: 0x3206, 0x0485: 0x351c,
+ 0x0486: 0x3201, 0x0487: 0x3517, 0x0488: 0x320b, 0x0489: 0x3526, 0x048a: 0x3210, 0x048b: 0x352b,
+ 0x048c: 0x3215, 0x048d: 0x3530, 0x048e: 0x3233, 0x048f: 0x354e, 0x0490: 0x324c, 0x0491: 0x356c,
+ 0x0492: 0x325b, 0x0493: 0x357b, 0x0494: 0x3260, 0x0495: 0x3580, 0x0496: 0x3364, 0x0497: 0x3490,
+ 0x0498: 0x3521, 0x0499: 0x355d, 0x049b: 0x35bb,
+ 0x04a0: 0x4687, 0x04a1: 0x4718, 0x04a2: 0x2f6d, 0x04a3: 0x3279,
+ 0x04a4: 0x3862, 0x04a5: 0x39f1, 0x04a6: 0x385b, 0x04a7: 0x39ea, 0x04a8: 0x3870, 0x04a9: 0x39ff,
+ 0x04aa: 0x3869, 0x04ab: 0x39f8, 0x04ac: 0x38a8, 0x04ad: 0x3a37, 0x04ae: 0x387e, 0x04af: 0x3a0d,
+ 0x04b0: 0x3877, 0x04b1: 0x3a06, 0x04b2: 0x388c, 0x04b3: 0x3a1b, 0x04b4: 0x3885, 0x04b5: 0x3a14,
+ 0x04b6: 0x38af, 0x04b7: 0x3a3e, 0x04b8: 0x469b, 0x04b9: 0x472c, 0x04ba: 0x2fea, 0x04bb: 0x32f6,
+ 0x04bc: 0x2fd6, 0x04bd: 0x32e2, 0x04be: 0x38c4, 0x04bf: 0x3a53,
+ // Block 0x13, offset 0x4c0
+ 0x04c0: 0x38bd, 0x04c1: 0x3a4c, 0x04c2: 0x38d2, 0x04c3: 0x3a61, 0x04c4: 0x38cb, 0x04c5: 0x3a5a,
+ 0x04c6: 0x38e7, 0x04c7: 0x3a76, 0x04c8: 0x307b, 0x04c9: 0x3387, 0x04ca: 0x308f, 0x04cb: 0x339b,
+ 0x04cc: 0x46cd, 0x04cd: 0x475e, 0x04ce: 0x3120, 0x04cf: 0x3431, 0x04d0: 0x390a, 0x04d1: 0x3a99,
+ 0x04d2: 0x3903, 0x04d3: 0x3a92, 0x04d4: 0x3918, 0x04d5: 0x3aa7, 0x04d6: 0x3911, 0x04d7: 0x3aa0,
+ 0x04d8: 0x3973, 0x04d9: 0x3b02, 0x04da: 0x3957, 0x04db: 0x3ae6, 0x04dc: 0x3950, 0x04dd: 0x3adf,
+ 0x04de: 0x3965, 0x04df: 0x3af4, 0x04e0: 0x395e, 0x04e1: 0x3aed, 0x04e2: 0x396c, 0x04e3: 0x3afb,
+ 0x04e4: 0x31cf, 0x04e5: 0x34e5, 0x04e6: 0x31b1, 0x04e7: 0x34c7, 0x04e8: 0x39ce, 0x04e9: 0x3b5d,
+ 0x04ea: 0x39c7, 0x04eb: 0x3b56, 0x04ec: 0x39dc, 0x04ed: 0x3b6b, 0x04ee: 0x39d5, 0x04ef: 0x3b64,
+ 0x04f0: 0x39e3, 0x04f1: 0x3b72, 0x04f2: 0x321a, 0x04f3: 0x3535, 0x04f4: 0x3242, 0x04f5: 0x3562,
+ 0x04f6: 0x323d, 0x04f7: 0x3558, 0x04f8: 0x3229, 0x04f9: 0x3544,
+ // Block 0x14, offset 0x500
+ 0x0500: 0x47ea, 0x0501: 0x47f0, 0x0502: 0x4904, 0x0503: 0x491c, 0x0504: 0x490c, 0x0505: 0x4924,
+ 0x0506: 0x4914, 0x0507: 0x492c, 0x0508: 0x4790, 0x0509: 0x4796, 0x050a: 0x4874, 0x050b: 0x488c,
+ 0x050c: 0x487c, 0x050d: 0x4894, 0x050e: 0x4884, 0x050f: 0x489c, 0x0510: 0x47fc, 0x0511: 0x4802,
+ 0x0512: 0x3da2, 0x0513: 0x3db2, 0x0514: 0x3daa, 0x0515: 0x3dba,
+ 0x0518: 0x479c, 0x0519: 0x47a2, 0x051a: 0x3cd2, 0x051b: 0x3ce2, 0x051c: 0x3cda, 0x051d: 0x3cea,
+ 0x0520: 0x4814, 0x0521: 0x481a, 0x0522: 0x4934, 0x0523: 0x494c,
+ 0x0524: 0x493c, 0x0525: 0x4954, 0x0526: 0x4944, 0x0527: 0x495c, 0x0528: 0x47a8, 0x0529: 0x47ae,
+ 0x052a: 0x48a4, 0x052b: 0x48bc, 0x052c: 0x48ac, 0x052d: 0x48c4, 0x052e: 0x48b4, 0x052f: 0x48cc,
+ 0x0530: 0x482c, 0x0531: 0x4832, 0x0532: 0x3e02, 0x0533: 0x3e1a, 0x0534: 0x3e0a, 0x0535: 0x3e22,
+ 0x0536: 0x3e12, 0x0537: 0x3e2a, 0x0538: 0x47b4, 0x0539: 0x47ba, 0x053a: 0x3d02, 0x053b: 0x3d1a,
+ 0x053c: 0x3d0a, 0x053d: 0x3d22, 0x053e: 0x3d12, 0x053f: 0x3d2a,
+ // Block 0x15, offset 0x540
+ 0x0540: 0x4838, 0x0541: 0x483e, 0x0542: 0x3e32, 0x0543: 0x3e42, 0x0544: 0x3e3a, 0x0545: 0x3e4a,
+ 0x0548: 0x47c0, 0x0549: 0x47c6, 0x054a: 0x3d32, 0x054b: 0x3d42,
+ 0x054c: 0x3d3a, 0x054d: 0x3d4a, 0x0550: 0x484a, 0x0551: 0x4850,
+ 0x0552: 0x3e6a, 0x0553: 0x3e82, 0x0554: 0x3e72, 0x0555: 0x3e8a, 0x0556: 0x3e7a, 0x0557: 0x3e92,
+ 0x0559: 0x47cc, 0x055b: 0x3d52, 0x055d: 0x3d5a,
+ 0x055f: 0x3d62, 0x0560: 0x4862, 0x0561: 0x4868, 0x0562: 0x4964, 0x0563: 0x497c,
+ 0x0564: 0x496c, 0x0565: 0x4984, 0x0566: 0x4974, 0x0567: 0x498c, 0x0568: 0x47d2, 0x0569: 0x47d8,
+ 0x056a: 0x48d4, 0x056b: 0x48ec, 0x056c: 0x48dc, 0x056d: 0x48f4, 0x056e: 0x48e4, 0x056f: 0x48fc,
+ 0x0570: 0x47de, 0x0571: 0x4304, 0x0572: 0x367b, 0x0573: 0x430a, 0x0574: 0x4808, 0x0575: 0x4310,
+ 0x0576: 0x368d, 0x0577: 0x4316, 0x0578: 0x36ab, 0x0579: 0x431c, 0x057a: 0x36c3, 0x057b: 0x4322,
+ 0x057c: 0x4856, 0x057d: 0x4328,
+ // Block 0x16, offset 0x580
+ 0x0580: 0x3d8a, 0x0581: 0x3d92, 0x0582: 0x416e, 0x0583: 0x418c, 0x0584: 0x4178, 0x0585: 0x4196,
+ 0x0586: 0x4182, 0x0587: 0x41a0, 0x0588: 0x3cc2, 0x0589: 0x3cca, 0x058a: 0x40ba, 0x058b: 0x40d8,
+ 0x058c: 0x40c4, 0x058d: 0x40e2, 0x058e: 0x40ce, 0x058f: 0x40ec, 0x0590: 0x3dd2, 0x0591: 0x3dda,
+ 0x0592: 0x41aa, 0x0593: 0x41c8, 0x0594: 0x41b4, 0x0595: 0x41d2, 0x0596: 0x41be, 0x0597: 0x41dc,
+ 0x0598: 0x3cf2, 0x0599: 0x3cfa, 0x059a: 0x40f6, 0x059b: 0x4114, 0x059c: 0x4100, 0x059d: 0x411e,
+ 0x059e: 0x410a, 0x059f: 0x4128, 0x05a0: 0x3eaa, 0x05a1: 0x3eb2, 0x05a2: 0x41e6, 0x05a3: 0x4204,
+ 0x05a4: 0x41f0, 0x05a5: 0x420e, 0x05a6: 0x41fa, 0x05a7: 0x4218, 0x05a8: 0x3d6a, 0x05a9: 0x3d72,
+ 0x05aa: 0x4132, 0x05ab: 0x4150, 0x05ac: 0x413c, 0x05ad: 0x415a, 0x05ae: 0x4146, 0x05af: 0x4164,
+ 0x05b0: 0x366f, 0x05b1: 0x3669, 0x05b2: 0x3d7a, 0x05b3: 0x3675, 0x05b4: 0x3d82,
+ 0x05b6: 0x47f6, 0x05b7: 0x3d9a, 0x05b8: 0x35df, 0x05b9: 0x35d9, 0x05ba: 0x35cd, 0x05bb: 0x42d4,
+ 0x05bc: 0x35e5, 0x05be: 0x01d3, 0x05bf: 0x8800,
+ // Block 0x17, offset 0x5c0
+ 0x05c1: 0x3591, 0x05c2: 0x3dc2, 0x05c3: 0x3687, 0x05c4: 0x3dca,
+ 0x05c6: 0x4820, 0x05c7: 0x3de2, 0x05c8: 0x35eb, 0x05c9: 0x42da, 0x05ca: 0x35f7, 0x05cb: 0x42e0,
+ 0x05cc: 0x3603, 0x05cd: 0x3b79, 0x05ce: 0x3b80, 0x05cf: 0x3b87, 0x05d0: 0x369f, 0x05d1: 0x3699,
+ 0x05d2: 0x3dea, 0x05d3: 0x44ca, 0x05d6: 0x36a5, 0x05d7: 0x3dfa,
+ 0x05d8: 0x361b, 0x05d9: 0x3615, 0x05da: 0x3609, 0x05db: 0x42e6, 0x05dd: 0x3b8e,
+ 0x05de: 0x3b95, 0x05df: 0x3b9c, 0x05e0: 0x36d5, 0x05e1: 0x36cf, 0x05e2: 0x3e52, 0x05e3: 0x44d2,
+ 0x05e4: 0x36b7, 0x05e5: 0x36bd, 0x05e6: 0x36db, 0x05e7: 0x3e62, 0x05e8: 0x364b, 0x05e9: 0x3645,
+ 0x05ea: 0x3639, 0x05eb: 0x42f2, 0x05ec: 0x3633, 0x05ed: 0x3585, 0x05ee: 0x42ce, 0x05ef: 0x0081,
+ 0x05f2: 0x3e9a, 0x05f3: 0x36e1, 0x05f4: 0x3ea2,
+ 0x05f6: 0x486e, 0x05f7: 0x3eba, 0x05f8: 0x3627, 0x05f9: 0x42ec, 0x05fa: 0x3657, 0x05fb: 0x42fe,
+ 0x05fc: 0x3663, 0x05fd: 0x00ce, 0x05fe: 0x8800,
+ // Block 0x18, offset 0x600
+ 0x0601: 0x3bf0, 0x0603: 0x8800, 0x0604: 0x3bf7, 0x0605: 0x8800,
+ 0x0607: 0x3bfe, 0x0608: 0x8800, 0x0609: 0x3c05,
+ 0x060d: 0x8800,
+ 0x0620: 0x2f4f, 0x0621: 0x8800, 0x0622: 0x3c13,
+ 0x0624: 0x8800, 0x0625: 0x8800,
+ 0x062d: 0x3c0c, 0x062e: 0x2f4a, 0x062f: 0x2f54,
+ 0x0630: 0x3c1a, 0x0631: 0x3c21, 0x0632: 0x8800, 0x0633: 0x8800, 0x0634: 0x3c28, 0x0635: 0x3c2f,
+ 0x0636: 0x8800, 0x0637: 0x8800, 0x0638: 0x3c36, 0x0639: 0x3c3d, 0x063a: 0x8800, 0x063b: 0x8800,
+ 0x063c: 0x8800, 0x063d: 0x8800,
+ // Block 0x19, offset 0x640
+ 0x0640: 0x3c44, 0x0641: 0x3c4b, 0x0642: 0x8800, 0x0643: 0x8800, 0x0644: 0x3c60, 0x0645: 0x3c67,
+ 0x0646: 0x8800, 0x0647: 0x8800, 0x0648: 0x3c6e, 0x0649: 0x3c75,
+ 0x0651: 0x8800,
+ 0x0652: 0x8800,
+ 0x0662: 0x8800,
+ 0x0668: 0x8800, 0x0669: 0x8800,
+ 0x066b: 0x8800, 0x066c: 0x3c8a, 0x066d: 0x3c91, 0x066e: 0x3c98, 0x066f: 0x3c9f,
+ 0x0672: 0x8800, 0x0673: 0x8800, 0x0674: 0x8800, 0x0675: 0x8800,
+ // Block 0x1a, offset 0x680
+ 0x0686: 0x8800, 0x068b: 0x8800,
+ 0x068c: 0x3ef2, 0x068d: 0x8800, 0x068e: 0x3efa, 0x068f: 0x8800, 0x0690: 0x3f02, 0x0691: 0x8800,
+ 0x0692: 0x3f0a, 0x0693: 0x8800, 0x0694: 0x3f12, 0x0695: 0x8800, 0x0696: 0x3f1a, 0x0697: 0x8800,
+ 0x0698: 0x3f22, 0x0699: 0x8800, 0x069a: 0x3f2a, 0x069b: 0x8800, 0x069c: 0x3f32, 0x069d: 0x8800,
+ 0x069e: 0x3f3a, 0x069f: 0x8800, 0x06a0: 0x3f42, 0x06a1: 0x8800, 0x06a2: 0x3f4a,
+ 0x06a4: 0x8800, 0x06a5: 0x3f52, 0x06a6: 0x8800, 0x06a7: 0x3f5a, 0x06a8: 0x8800, 0x06a9: 0x3f62,
+ 0x06af: 0x8800,
+ 0x06b0: 0x3f6a, 0x06b1: 0x3f72, 0x06b2: 0x8800, 0x06b3: 0x3f7a, 0x06b4: 0x3f82, 0x06b5: 0x8800,
+ 0x06b6: 0x3f8a, 0x06b7: 0x3f92, 0x06b8: 0x8800, 0x06b9: 0x3f9a, 0x06ba: 0x3fa2, 0x06bb: 0x8800,
+ 0x06bc: 0x3faa, 0x06bd: 0x3fb2,
+ // Block 0x1b, offset 0x6c0
+ 0x06d4: 0x3eea,
+ 0x06d9: 0x8608, 0x06da: 0x8608, 0x06dd: 0x8800,
+ 0x06de: 0x3fba,
+ 0x06e6: 0x8800,
+ 0x06eb: 0x8800, 0x06ec: 0x3fca, 0x06ed: 0x8800, 0x06ee: 0x3fd2, 0x06ef: 0x8800,
+ 0x06f0: 0x3fda, 0x06f1: 0x8800, 0x06f2: 0x3fe2, 0x06f3: 0x8800, 0x06f4: 0x3fea, 0x06f5: 0x8800,
+ 0x06f6: 0x3ff2, 0x06f7: 0x8800, 0x06f8: 0x3ffa, 0x06f9: 0x8800, 0x06fa: 0x4002, 0x06fb: 0x8800,
+ 0x06fc: 0x400a, 0x06fd: 0x8800, 0x06fe: 0x4012, 0x06ff: 0x8800,
+ // Block 0x1c, offset 0x700
+ 0x0700: 0x401a, 0x0701: 0x8800, 0x0702: 0x4022, 0x0704: 0x8800, 0x0705: 0x402a,
+ 0x0706: 0x8800, 0x0707: 0x4032, 0x0708: 0x8800, 0x0709: 0x403a,
+ 0x070f: 0x8800, 0x0710: 0x4042, 0x0711: 0x404a,
+ 0x0712: 0x8800, 0x0713: 0x4052, 0x0714: 0x405a, 0x0715: 0x8800, 0x0716: 0x4062, 0x0717: 0x406a,
+ 0x0718: 0x8800, 0x0719: 0x4072, 0x071a: 0x407a, 0x071b: 0x8800, 0x071c: 0x4082, 0x071d: 0x408a,
+ 0x072f: 0x8800,
+ 0x0730: 0x8800, 0x0731: 0x8800, 0x0732: 0x8800, 0x0734: 0x3fc2,
+ 0x0737: 0x4092, 0x0738: 0x409a, 0x0739: 0x40a2, 0x073a: 0x40aa,
+ 0x073d: 0x8800, 0x073e: 0x40b2,
+ // Block 0x1d, offset 0x740
+ 0x0740: 0x13e9, 0x0741: 0x0d6d, 0x0742: 0x1445, 0x0743: 0x1411, 0x0744: 0x0ec9, 0x0745: 0x075d,
+ 0x0746: 0x0951, 0x0747: 0x1699, 0x0748: 0x1699, 0x0749: 0x0a7d, 0x074a: 0x14cd, 0x074b: 0x09b5,
+ 0x074c: 0x0a79, 0x074d: 0x0c61, 0x074e: 0x1041, 0x074f: 0x11d1, 0x0750: 0x1309, 0x0751: 0x1345,
+ 0x0752: 0x1379, 0x0753: 0x148d, 0x0754: 0x0de5, 0x0755: 0x0e71, 0x0756: 0x0f1d, 0x0757: 0x0fb5,
+ 0x0758: 0x12d1, 0x0759: 0x14b5, 0x075a: 0x15e1, 0x075b: 0x0781, 0x075c: 0x0925, 0x075d: 0x0df9,
+ 0x075e: 0x0f41, 0x075f: 0x1305, 0x0760: 0x1631, 0x0761: 0x0b25, 0x0762: 0x0ee9, 0x0763: 0x12f5,
+ 0x0764: 0x1389, 0x0765: 0x0c95, 0x0766: 0x122d, 0x0767: 0x1351, 0x0768: 0x0b91, 0x0769: 0x0d81,
+ 0x076a: 0x0e89, 0x076b: 0x0f8d, 0x076c: 0x1499, 0x076d: 0x07c1, 0x076e: 0x0859, 0x076f: 0x08c5,
+ 0x0770: 0x0cfd, 0x0771: 0x0df1, 0x0772: 0x0f3d, 0x0773: 0x1061, 0x0774: 0x11e9, 0x0775: 0x12fd,
+ 0x0776: 0x1315, 0x0777: 0x1439, 0x0778: 0x155d, 0x0779: 0x1611, 0x077a: 0x162d, 0x077b: 0x109d,
+ 0x077c: 0x10dd, 0x077d: 0x1195, 0x077e: 0x12b5, 0x077f: 0x14e9,
+ // Block 0x1e, offset 0x780
+ 0x0780: 0x1639, 0x0781: 0x13bd, 0x0782: 0x0a39, 0x0783: 0x0bad, 0x0784: 0x114d, 0x0785: 0x120d,
+ 0x0786: 0x0f71, 0x0787: 0x10a5, 0x0788: 0x1409, 0x0789: 0x1555, 0x078a: 0x0a35, 0x078b: 0x0b01,
+ 0x078c: 0x0de9, 0x078d: 0x0e9d, 0x078e: 0x0ed1, 0x078f: 0x1185, 0x0790: 0x11ad, 0x0791: 0x1515,
+ 0x0792: 0x08c1, 0x0793: 0x1219, 0x0794: 0x0865, 0x0795: 0x0861, 0x0796: 0x1109, 0x0797: 0x1199,
+ 0x0798: 0x12cd, 0x0799: 0x151d, 0x079a: 0x13d9, 0x079b: 0x0c99, 0x079c: 0x0de5, 0x079d: 0x13c9,
+ 0x079e: 0x0769, 0x079f: 0x0ad5, 0x07a0: 0x0c05, 0x07a1: 0x0fa1, 0x07a2: 0x1021, 0x07a3: 0x08e5,
+ 0x07a4: 0x10ad, 0x07a5: 0x07d1, 0x07a6: 0x0be9, 0x07a7: 0x0749, 0x07a8: 0x0e5d, 0x07a9: 0x0d15,
+ 0x07aa: 0x1181, 0x07ab: 0x0939, 0x07ac: 0x0a25, 0x07ad: 0x106d, 0x07ae: 0x12d5, 0x07af: 0x13ad,
+ 0x07b0: 0x0e29, 0x07b1: 0x1469, 0x07b2: 0x0e55, 0x07b3: 0x0ca9, 0x07b4: 0x128d, 0x07b5: 0x0cc9,
+ 0x07b6: 0x101d, 0x07b7: 0x079d, 0x07b8: 0x0819, 0x07b9: 0x085d, 0x07ba: 0x0dc5, 0x07bb: 0x116d,
+ 0x07bc: 0x1265, 0x07bd: 0x13b9, 0x07be: 0x14c9, 0x07bf: 0x08cd,
+ // Block 0x1f, offset 0x7c0
+ 0x07c0: 0x0981, 0x07c1: 0x0a89, 0x07c2: 0x0ba1, 0x07c3: 0x0d31, 0x07c4: 0x0eed, 0x07c5: 0x10b1,
+ 0x07c6: 0x1505, 0x07c7: 0x15e9, 0x07c8: 0x163d, 0x07c9: 0x1655, 0x07ca: 0x08a9, 0x07cb: 0x0d65,
+ 0x07cc: 0x0e15, 0x07cd: 0x145d, 0x07ce: 0x0b6d, 0x07cf: 0x0c49, 0x07d0: 0x0c65, 0x07d1: 0x0cf5,
+ 0x07d2: 0x0edd, 0x07d3: 0x0f29, 0x07d4: 0x0fd9, 0x07d5: 0x10fd, 0x07d6: 0x11a1, 0x07d7: 0x1205,
+ 0x07d8: 0x144d, 0x07d9: 0x12dd, 0x07da: 0x1475, 0x07db: 0x14ed, 0x07dc: 0x0881, 0x07dd: 0x08ad,
+ 0x07de: 0x0995, 0x07df: 0x0f19, 0x07e0: 0x1365, 0x07e1: 0x13ad, 0x07e2: 0x0b8d, 0x07e3: 0x0bfd,
+ 0x07e4: 0x0cc1, 0x07e5: 0x0e21, 0x07e6: 0x1149, 0x07e7: 0x0f95, 0x07e8: 0x07ad, 0x07e9: 0x09f1,
+ 0x07ea: 0x0ad5, 0x07eb: 0x0b39, 0x07ec: 0x0c09, 0x07ed: 0x0fb1, 0x07ee: 0x0fcd, 0x07ef: 0x11dd,
+ 0x07f0: 0x11fd, 0x07f1: 0x14d1, 0x07f2: 0x1551, 0x07f3: 0x1561, 0x07f4: 0x159d, 0x07f5: 0x07c5,
+ 0x07f6: 0x10f1, 0x07f7: 0x14bd, 0x07f8: 0x1539, 0x07f9: 0x0c21, 0x07fa: 0x0789, 0x07fb: 0x07e9,
+ 0x07fc: 0x0ad9, 0x07fd: 0x0af9, 0x07fe: 0x0d21, 0x07ff: 0x0de5,
+ // Block 0x20, offset 0x800
+ 0x0800: 0x0f35, 0x0801: 0x103d, 0x0802: 0x12e9, 0x0803: 0x1489, 0x0804: 0x1691, 0x0805: 0x0d55,
+ 0x0806: 0x1511, 0x0807: 0x08a5, 0x0808: 0x0da1, 0x0809: 0x0dad, 0x080a: 0x0e81, 0x080b: 0x0eb9,
+ 0x080c: 0x0fbd, 0x080d: 0x1019, 0x080e: 0x1099, 0x080f: 0x117d, 0x0810: 0x15a9, 0x0811: 0x0821,
+ 0x0812: 0x0c75, 0x0813: 0x1521, 0x0814: 0x07d9, 0x0815: 0x0b1d, 0x0816: 0x0ea1, 0x0817: 0x1451,
+ 0x0818: 0x0bd9, 0x0819: 0x0c29, 0x081a: 0x0db5, 0x081b: 0x0fa1, 0x081c: 0x1529, 0x081d: 0x0889,
+ 0x081e: 0x0971, 0x081f: 0x0b09, 0x0820: 0x0d45, 0x0821: 0x0d91, 0x0822: 0x0dd1, 0x0823: 0x0e65,
+ 0x0824: 0x0fb9, 0x0825: 0x102d, 0x0826: 0x11c9, 0x0827: 0x1369, 0x0828: 0x1375, 0x0829: 0x14c5,
+ 0x082a: 0x1545, 0x082b: 0x08f5, 0x082c: 0x0ebd, 0x082d: 0x0975, 0x082e: 0x0f39, 0x082f: 0x0fdd,
+ 0x0830: 0x12f9, 0x0831: 0x152d, 0x0832: 0x1619, 0x0833: 0x1641, 0x0834: 0x0da9, 0x0835: 0x0e99,
+ 0x0836: 0x1235, 0x0837: 0x1129, 0x0838: 0x1135, 0x0839: 0x1159, 0x083a: 0x0f89, 0x083b: 0x0f11,
+ 0x083c: 0x13d5, 0x083d: 0x07a5, 0x083e: 0x129d, 0x083f: 0x088d,
+ // Block 0x21, offset 0x840
+ 0x0840: 0x087d, 0x0841: 0x0b7d, 0x0842: 0x0c9d, 0x0843: 0x1165, 0x0844: 0x0ac5, 0x0845: 0x0e75,
+ 0x0846: 0x0d61, 0x0847: 0x1459, 0x0848: 0x1359, 0x0849: 0x1519, 0x084a: 0x1395, 0x084b: 0x0b99,
+ 0x084c: 0x07f9, 0x084d: 0x09cd, 0x0850: 0x0a21,
+ 0x0852: 0x0d51, 0x0855: 0x0869, 0x0856: 0x0f91, 0x0857: 0x1055,
+ 0x0858: 0x10b9, 0x0859: 0x10d5, 0x085a: 0x10d9, 0x085b: 0x10ed, 0x085c: 0x1569, 0x085d: 0x115d,
+ 0x085e: 0x11e1, 0x0860: 0x1301, 0x0862: 0x13c5,
+ 0x0865: 0x1479, 0x0866: 0x14a5,
+ 0x086a: 0x15bd, 0x086b: 0x15c1, 0x086c: 0x15c5, 0x086d: 0x1629, 0x086e: 0x149d, 0x086f: 0x1535,
+ 0x0870: 0x07c9, 0x0871: 0x07ed, 0x0872: 0x0801, 0x0873: 0x08bd, 0x0874: 0x08c9, 0x0875: 0x0909,
+ 0x0876: 0x09bd, 0x0877: 0x09d9, 0x0878: 0x09e1, 0x0879: 0x0a1d, 0x087a: 0x0a29, 0x087b: 0x0b05,
+ 0x087c: 0x0b0d, 0x087d: 0x0c15, 0x087e: 0x0c3d, 0x087f: 0x0c45,
+ // Block 0x22, offset 0x880
+ 0x0880: 0x0c5d, 0x0881: 0x0d09, 0x0882: 0x0d39, 0x0883: 0x0d59, 0x0884: 0x0dc9, 0x0885: 0x0e8d,
+ 0x0886: 0x0ea9, 0x0887: 0x0ed9, 0x0888: 0x0f2d, 0x0889: 0x0f4d, 0x088a: 0x0fc1, 0x088b: 0x10a1,
+ 0x088c: 0x10bd, 0x088d: 0x10c5, 0x088e: 0x10c1, 0x088f: 0x10c9, 0x0890: 0x10cd, 0x0891: 0x10d1,
+ 0x0892: 0x10e5, 0x0893: 0x10e9, 0x0894: 0x110d, 0x0895: 0x1121, 0x0896: 0x113d, 0x0897: 0x11a1,
+ 0x0898: 0x11a9, 0x0899: 0x11b1, 0x089a: 0x11c5, 0x089b: 0x11ed, 0x089c: 0x123d, 0x089d: 0x1271,
+ 0x089e: 0x1271, 0x089f: 0x12d9, 0x08a0: 0x1381, 0x08a1: 0x1399, 0x08a2: 0x13cd, 0x08a3: 0x13d1,
+ 0x08a4: 0x1415, 0x08a5: 0x1419, 0x08a6: 0x1471, 0x08a7: 0x1479, 0x08a8: 0x1549, 0x08a9: 0x158d,
+ 0x08aa: 0x15a5, 0x08ab: 0x0c0d, 0x08ac: 0x1780, 0x08ad: 0x1255,
+ 0x08b0: 0x0751, 0x08b1: 0x0855, 0x08b2: 0x0815, 0x08b3: 0x07bd, 0x08b4: 0x07fd, 0x08b5: 0x0829,
+ 0x08b6: 0x08b9, 0x08b7: 0x08d5, 0x08b8: 0x09bd, 0x08b9: 0x09a9, 0x08ba: 0x09b9, 0x08bb: 0x09d5,
+ 0x08bc: 0x0a21, 0x08bd: 0x0a31, 0x08be: 0x0a75, 0x08bf: 0x0a81,
+ // Block 0x23, offset 0x8c0
+ 0x08c0: 0x0a9d, 0x08c1: 0x0aad, 0x08c2: 0x0b95, 0x08c3: 0x0b9d, 0x08c4: 0x0bcd, 0x08c5: 0x0bed,
+ 0x08c6: 0x0c1d, 0x08c7: 0x0c35, 0x08c8: 0x0c25, 0x08c9: 0x0c45, 0x08ca: 0x0c39, 0x08cb: 0x0c5d,
+ 0x08cc: 0x0c79, 0x08cd: 0x0cd1, 0x08ce: 0x0cdd, 0x08cf: 0x0ce5, 0x08d0: 0x0d0d, 0x08d1: 0x0d51,
+ 0x08d2: 0x0d81, 0x08d3: 0x0d85, 0x08d4: 0x0d99, 0x08d5: 0x0e19, 0x08d6: 0x0e29, 0x08d7: 0x0e81,
+ 0x08d8: 0x0ecd, 0x08d9: 0x0ec5, 0x08da: 0x0ed9, 0x08db: 0x0ef5, 0x08dc: 0x0f2d, 0x08dd: 0x1085,
+ 0x08de: 0x0f51, 0x08df: 0x0f85, 0x08e0: 0x0f91, 0x08e1: 0x0fd1, 0x08e2: 0x0fed, 0x08e3: 0x1011,
+ 0x08e4: 0x1035, 0x08e5: 0x1039, 0x08e6: 0x1055, 0x08e7: 0x1059, 0x08e8: 0x1069, 0x08e9: 0x107d,
+ 0x08ea: 0x1079, 0x08eb: 0x10a9, 0x08ec: 0x1125, 0x08ed: 0x113d, 0x08ee: 0x1155, 0x08ef: 0x118d,
+ 0x08f0: 0x11a1, 0x08f1: 0x11bd, 0x08f2: 0x11ed, 0x08f3: 0x12a1, 0x08f4: 0x12c9, 0x08f5: 0x133d,
+ 0x08f6: 0x1385, 0x08f7: 0x1391, 0x08f8: 0x1399, 0x08f9: 0x13b1, 0x08fa: 0x13c5, 0x08fb: 0x13b5,
+ 0x08fc: 0x13cd, 0x08fd: 0x13c9, 0x08fe: 0x13c1, 0x08ff: 0x13d1,
+ // Block 0x24, offset 0x900
+ 0x0900: 0x13dd, 0x0901: 0x1419, 0x0902: 0x1455, 0x0903: 0x1485, 0x0904: 0x14b9, 0x0905: 0x14d9,
+ 0x0906: 0x1525, 0x0907: 0x1549, 0x0908: 0x1569, 0x0909: 0x157d, 0x090a: 0x158d, 0x090b: 0x1599,
+ 0x090c: 0x15a5, 0x090d: 0x15f9, 0x090e: 0x1699, 0x090f: 0x1717, 0x0910: 0x1712, 0x0911: 0x1744,
+ 0x0912: 0x0679, 0x0913: 0x06a1, 0x0914: 0x06a5, 0x0915: 0x17c6, 0x0916: 0x17f3, 0x0917: 0x186b,
+ 0x0918: 0x1685, 0x0919: 0x1695,
+ // Block 0x25, offset 0x940
+ 0x0940: 0x076d, 0x0941: 0x0765, 0x0942: 0x0775, 0x0943: 0x16a9, 0x0944: 0x07b9, 0x0945: 0x07c9,
+ 0x0946: 0x07cd, 0x0947: 0x07d5, 0x0948: 0x07dd, 0x0949: 0x07e1, 0x094a: 0x07ed, 0x094b: 0x07e5,
+ 0x094c: 0x0625, 0x094d: 0x16bd, 0x094e: 0x0801, 0x094f: 0x0805, 0x0950: 0x0809, 0x0951: 0x0825,
+ 0x0952: 0x16ae, 0x0953: 0x0629, 0x0954: 0x0811, 0x0955: 0x0831, 0x0956: 0x16b8, 0x0957: 0x0841,
+ 0x0958: 0x0849, 0x0959: 0x07a9, 0x095a: 0x0851, 0x095b: 0x0855, 0x095c: 0x1893, 0x095d: 0x0871,
+ 0x095e: 0x0879, 0x095f: 0x0631, 0x0960: 0x0891, 0x0961: 0x0895, 0x0962: 0x089d, 0x0963: 0x08a1,
+ 0x0964: 0x0635, 0x0965: 0x08b9, 0x0966: 0x08bd, 0x0967: 0x08c9, 0x0968: 0x08d5, 0x0969: 0x08d9,
+ 0x096a: 0x08dd, 0x096b: 0x08e5, 0x096c: 0x0905, 0x096d: 0x0909, 0x096e: 0x0911, 0x096f: 0x0921,
+ 0x0970: 0x0929, 0x0971: 0x092d, 0x0972: 0x092d, 0x0973: 0x092d, 0x0974: 0x16cc, 0x0975: 0x0f05,
+ 0x0976: 0x0941, 0x0977: 0x0949, 0x0978: 0x16d1, 0x0979: 0x0955, 0x097a: 0x095d, 0x097b: 0x0965,
+ 0x097c: 0x098d, 0x097d: 0x0979, 0x097e: 0x0985, 0x097f: 0x0989,
+ // Block 0x26, offset 0x980
+ 0x0980: 0x0991, 0x0981: 0x0999, 0x0982: 0x099d, 0x0983: 0x09a5, 0x0984: 0x09ad, 0x0985: 0x09b1,
+ 0x0986: 0x09b1, 0x0987: 0x09b9, 0x0988: 0x09c1, 0x0989: 0x09c5, 0x098a: 0x09d1, 0x098b: 0x09f5,
+ 0x098c: 0x09d9, 0x098d: 0x09f9, 0x098e: 0x09dd, 0x098f: 0x09e5, 0x0990: 0x087d, 0x0991: 0x0a41,
+ 0x0992: 0x0a09, 0x0993: 0x0a0d, 0x0994: 0x0a11, 0x0995: 0x0a05, 0x0996: 0x0a19, 0x0997: 0x0a15,
+ 0x0998: 0x0a2d, 0x0999: 0x16d6, 0x099a: 0x0a49, 0x099b: 0x0a4d, 0x099c: 0x0a55, 0x099d: 0x0a61,
+ 0x099e: 0x0a69, 0x099f: 0x0a85, 0x09a0: 0x16db, 0x09a1: 0x16e0, 0x09a2: 0x0a91, 0x09a3: 0x0a95,
+ 0x09a4: 0x0a99, 0x09a5: 0x0a8d, 0x09a6: 0x0aa1, 0x09a7: 0x0639, 0x09a8: 0x063d, 0x09a9: 0x0aa9,
+ 0x09aa: 0x0ab1, 0x09ab: 0x0ab1, 0x09ac: 0x16e5, 0x09ad: 0x0acd, 0x09ae: 0x0ad1, 0x09af: 0x0ad5,
+ 0x09b0: 0x0add, 0x09b1: 0x16ea, 0x09b2: 0x0ae5, 0x09b3: 0x0ae9, 0x09b4: 0x0bc1, 0x09b5: 0x0af1,
+ 0x09b6: 0x0641, 0x09b7: 0x0afd, 0x09b8: 0x0b0d, 0x09b9: 0x0b19, 0x09ba: 0x0b15, 0x09bb: 0x16f4,
+ 0x09bc: 0x0b21, 0x09bd: 0x16f9, 0x09be: 0x0b2d, 0x09bf: 0x0b29,
+ // Block 0x27, offset 0x9c0
+ 0x09c0: 0x0b31, 0x09c1: 0x0b41, 0x09c2: 0x0b45, 0x09c3: 0x0645, 0x09c4: 0x0b55, 0x09c5: 0x0b5d,
+ 0x09c6: 0x0b61, 0x09c7: 0x0b65, 0x09c8: 0x0649, 0x09c9: 0x16fe, 0x09ca: 0x064d, 0x09cb: 0x0b81,
+ 0x09cc: 0x0b85, 0x09cd: 0x0b89, 0x09ce: 0x0b91, 0x09cf: 0x18c5, 0x09d0: 0x0ba9, 0x09d1: 0x1708,
+ 0x09d2: 0x1708, 0x09d3: 0x1249, 0x09d4: 0x0bb9, 0x09d5: 0x0bb9, 0x09d6: 0x0651, 0x09d7: 0x172b,
+ 0x09d8: 0x17fd, 0x09d9: 0x0bc9, 0x09da: 0x0bd1, 0x09db: 0x0655, 0x09dc: 0x0be5, 0x09dd: 0x0bf5,
+ 0x09de: 0x0bf9, 0x09df: 0x0c01, 0x09e0: 0x0c11, 0x09e1: 0x065d, 0x09e2: 0x0659, 0x09e3: 0x0c15,
+ 0x09e4: 0x170d, 0x09e5: 0x0c19, 0x09e6: 0x0c2d, 0x09e7: 0x0c31, 0x09e8: 0x0c35, 0x09e9: 0x0c31,
+ 0x09ea: 0x0c41, 0x09eb: 0x0c45, 0x09ec: 0x0c55, 0x09ed: 0x0c4d, 0x09ee: 0x0c51, 0x09ef: 0x0c59,
+ 0x09f0: 0x0c5d, 0x09f1: 0x0c61, 0x09f2: 0x0c6d, 0x09f3: 0x0c71, 0x09f4: 0x0c89, 0x09f5: 0x0c91,
+ 0x09f6: 0x0ca1, 0x09f7: 0x0cb5, 0x09f8: 0x171c, 0x09f9: 0x0cb1, 0x09fa: 0x0ca5, 0x09fb: 0x0cbd,
+ 0x09fc: 0x0cc5, 0x09fd: 0x0cd9, 0x09fe: 0x1721, 0x09ff: 0x0ce1,
+ // Block 0x28, offset 0xa00
+ 0x0a00: 0x0cd5, 0x0a01: 0x0ccd, 0x0a02: 0x0661, 0x0a03: 0x0ce9, 0x0a04: 0x0cf1, 0x0a05: 0x0cf9,
+ 0x0a06: 0x0ced, 0x0a07: 0x0665, 0x0a08: 0x0d09, 0x0a09: 0x0d11, 0x0a0a: 0x1726, 0x0a0b: 0x0d3d,
+ 0x0a0c: 0x0d71, 0x0a0d: 0x0d4d, 0x0a0e: 0x0671, 0x0a0f: 0x0d59, 0x0a10: 0x066d, 0x0a11: 0x0669,
+ 0x0a12: 0x0835, 0x0a13: 0x0839, 0x0a14: 0x0d75, 0x0a15: 0x0d5d, 0x0a16: 0x121d, 0x0a17: 0x06d5,
+ 0x0a18: 0x0d81, 0x0a19: 0x0d85, 0x0a1a: 0x0d89, 0x0a1b: 0x0d9d, 0x0a1c: 0x0d95, 0x0a1d: 0x173f,
+ 0x0a1e: 0x0675, 0x0a1f: 0x0db1, 0x0a20: 0x0da5, 0x0a21: 0x0dc1, 0x0a22: 0x0dc9, 0x0a23: 0x1749,
+ 0x0a24: 0x0dcd, 0x0a25: 0x0db9, 0x0a26: 0x0dd5, 0x0a27: 0x0679, 0x0a28: 0x0dd9, 0x0a29: 0x0ddd,
+ 0x0a2a: 0x0de1, 0x0a2b: 0x0ded, 0x0a2c: 0x174e, 0x0a2d: 0x0df5, 0x0a2e: 0x067d, 0x0a2f: 0x0e01,
+ 0x0a30: 0x1753, 0x0a31: 0x0e05, 0x0a32: 0x0681, 0x0a33: 0x0e11, 0x0a34: 0x0e1d, 0x0a35: 0x0e29,
+ 0x0a36: 0x0e2d, 0x0a37: 0x1758, 0x0a38: 0x16ef, 0x0a39: 0x175d, 0x0a3a: 0x0e4d, 0x0a3b: 0x1762,
+ 0x0a3c: 0x0e59, 0x0a3d: 0x0e61, 0x0a3e: 0x0e51, 0x0a3f: 0x0e6d,
+ // Block 0x29, offset 0xa40
+ 0x0a40: 0x0e7d, 0x0a41: 0x0e8d, 0x0a42: 0x0e81, 0x0a43: 0x0e85, 0x0a44: 0x0e91, 0x0a45: 0x0e95,
+ 0x0a46: 0x1767, 0x0a47: 0x0e79, 0x0a48: 0x0ead, 0x0a49: 0x0eb1, 0x0a4a: 0x0685, 0x0a4b: 0x0ec5,
+ 0x0a4c: 0x0ec1, 0x0a4d: 0x176c, 0x0a4e: 0x0ea5, 0x0a4f: 0x0ee1, 0x0a50: 0x1771, 0x0a51: 0x1776,
+ 0x0a52: 0x0ee5, 0x0a53: 0x0ef9, 0x0a54: 0x0ef5, 0x0a55: 0x0ef1, 0x0a56: 0x0689, 0x0a57: 0x0efd,
+ 0x0a58: 0x0f0d, 0x0a59: 0x0f09, 0x0a5a: 0x0f15, 0x0a5b: 0x16b3, 0x0a5c: 0x0f25, 0x0a5d: 0x177b,
+ 0x0a5e: 0x0f31, 0x0a5f: 0x1785, 0x0a60: 0x0f45, 0x0a61: 0x0f51, 0x0a62: 0x0f65, 0x0a63: 0x178a,
+ 0x0a64: 0x0f79, 0x0a65: 0x0f7d, 0x0a66: 0x178f, 0x0a67: 0x1794, 0x0a68: 0x0f99, 0x0a69: 0x0fa9,
+ 0x0a6a: 0x068d, 0x0a6b: 0x0fad, 0x0a6c: 0x0691, 0x0a6d: 0x0691, 0x0a6e: 0x0fc5, 0x0a6f: 0x0fc9,
+ 0x0a70: 0x0fd1, 0x0a71: 0x0fd5, 0x0a72: 0x0fe1, 0x0a73: 0x0695, 0x0a74: 0x0ff9, 0x0a75: 0x1799,
+ 0x0a76: 0x1015, 0x0a77: 0x179e, 0x0a78: 0x1021, 0x0a79: 0x1703, 0x0a7a: 0x1031, 0x0a7b: 0x17a3,
+ 0x0a7c: 0x17a8, 0x0a7d: 0x17ad, 0x0a7e: 0x0699, 0x0a7f: 0x069d,
+ // Block 0x2a, offset 0xa80
+ 0x0a80: 0x1069, 0x0a81: 0x17b7, 0x0a82: 0x17b2, 0x0a83: 0x17bc, 0x0a84: 0x17c1, 0x0a85: 0x1071,
+ 0x0a86: 0x1075, 0x0a87: 0x1075, 0x0a88: 0x107d, 0x0a89: 0x06a5, 0x0a8a: 0x1081, 0x0a8b: 0x06a9,
+ 0x0a8c: 0x06ad, 0x0a8d: 0x17cb, 0x0a8e: 0x1095, 0x0a8f: 0x109d, 0x0a90: 0x10a9, 0x0a91: 0x06b1,
+ 0x0a92: 0x17d0, 0x0a93: 0x10cd, 0x0a94: 0x17d5, 0x0a95: 0x17da, 0x0a96: 0x10ed, 0x0a97: 0x1105,
+ 0x0a98: 0x06b5, 0x0a99: 0x110d, 0x0a9a: 0x1111, 0x0a9b: 0x1115, 0x0a9c: 0x17df, 0x0a9d: 0x17e4,
+ 0x0a9e: 0x17e4, 0x0a9f: 0x112d, 0x0aa0: 0x06b9, 0x0aa1: 0x17e9, 0x0aa2: 0x1141, 0x0aa3: 0x1145,
+ 0x0aa4: 0x06bd, 0x0aa5: 0x17ee, 0x0aa6: 0x1161, 0x0aa7: 0x06c1, 0x0aa8: 0x1171, 0x0aa9: 0x1169,
+ 0x0aaa: 0x1179, 0x0aab: 0x17f8, 0x0aac: 0x1191, 0x0aad: 0x06c5, 0x0aae: 0x119d, 0x0aaf: 0x11a5,
+ 0x0ab0: 0x11b5, 0x0ab1: 0x06c9, 0x0ab2: 0x1802, 0x0ab3: 0x1807, 0x0ab4: 0x06cd, 0x0ab5: 0x180c,
+ 0x0ab6: 0x11cd, 0x0ab7: 0x1811, 0x0ab8: 0x11d9, 0x0ab9: 0x11e5, 0x0aba: 0x11ed, 0x0abb: 0x1816,
+ 0x0abc: 0x181b, 0x0abd: 0x1201, 0x0abe: 0x1820, 0x0abf: 0x1209,
+ // Block 0x2b, offset 0xac0
+ 0x0ac0: 0x1730, 0x0ac1: 0x06d1, 0x0ac2: 0x1221, 0x0ac3: 0x1225, 0x0ac4: 0x06d9, 0x0ac5: 0x1229,
+ 0x0ac6: 0x0aa5, 0x0ac7: 0x1825, 0x0ac8: 0x182a, 0x0ac9: 0x1735, 0x0aca: 0x173a, 0x0acb: 0x1249,
+ 0x0acc: 0x124d, 0x0acd: 0x1465, 0x0ace: 0x06dd, 0x0acf: 0x1279, 0x0ad0: 0x1275, 0x0ad1: 0x127d,
+ 0x0ad2: 0x08b1, 0x0ad3: 0x1281, 0x0ad4: 0x1285, 0x0ad5: 0x1289, 0x0ad6: 0x1291, 0x0ad7: 0x182f,
+ 0x0ad8: 0x128d, 0x0ad9: 0x1295, 0x0ada: 0x12a9, 0x0adb: 0x12ad, 0x0adc: 0x1299, 0x0add: 0x12b1,
+ 0x0ade: 0x12c5, 0x0adf: 0x12d9, 0x0ae0: 0x12a5, 0x0ae1: 0x12b9, 0x0ae2: 0x12bd, 0x0ae3: 0x12c1,
+ 0x0ae4: 0x1834, 0x0ae5: 0x183e, 0x0ae6: 0x1839, 0x0ae7: 0x06e1, 0x0ae8: 0x12e1, 0x0ae9: 0x12e5,
+ 0x0aea: 0x12ed, 0x0aeb: 0x1852, 0x0aec: 0x12f1, 0x0aed: 0x1843, 0x0aee: 0x06e5, 0x0aef: 0x06e9,
+ 0x0af0: 0x1848, 0x0af1: 0x184d, 0x0af2: 0x06ed, 0x0af3: 0x1311, 0x0af4: 0x1315, 0x0af5: 0x1319,
+ 0x0af6: 0x131d, 0x0af7: 0x1329, 0x0af8: 0x1325, 0x0af9: 0x1331, 0x0afa: 0x132d, 0x0afb: 0x133d,
+ 0x0afc: 0x1335, 0x0afd: 0x1339, 0x0afe: 0x1341, 0x0aff: 0x06f1,
+ // Block 0x2c, offset 0xb00
+ 0x0b00: 0x1349, 0x0b01: 0x134d, 0x0b02: 0x06f5, 0x0b03: 0x135d, 0x0b04: 0x1361, 0x0b05: 0x1857,
+ 0x0b06: 0x136d, 0x0b07: 0x1371, 0x0b08: 0x06f9, 0x0b09: 0x137d, 0x0b0a: 0x062d, 0x0b0b: 0x185c,
+ 0x0b0c: 0x1861, 0x0b0d: 0x06fd, 0x0b0e: 0x0701, 0x0b0f: 0x13a9, 0x0b10: 0x13c1, 0x0b11: 0x13dd,
+ 0x0b12: 0x13ed, 0x0b13: 0x1866, 0x0b14: 0x1401, 0x0b15: 0x1405, 0x0b16: 0x141d, 0x0b17: 0x1429,
+ 0x0b18: 0x1870, 0x0b19: 0x16c2, 0x0b1a: 0x1435, 0x0b1b: 0x1431, 0x0b1c: 0x143d, 0x0b1d: 0x16c7,
+ 0x0b1e: 0x1449, 0x0b1f: 0x1455, 0x0b20: 0x1875, 0x0b21: 0x187a, 0x0b22: 0x1495, 0x0b23: 0x14a1,
+ 0x0b24: 0x14a9, 0x0b25: 0x187f, 0x0b26: 0x14ad, 0x0b27: 0x14d5, 0x0b28: 0x14e1, 0x0b29: 0x14e5,
+ 0x0b2a: 0x14dd, 0x0b2b: 0x14f1, 0x0b2c: 0x14f5, 0x0b2d: 0x1884, 0x0b2e: 0x1501, 0x0b2f: 0x0705,
+ 0x0b30: 0x1509, 0x0b31: 0x1889, 0x0b32: 0x0709, 0x0b33: 0x1541, 0x0b34: 0x0b35, 0x0b35: 0x1559,
+ 0x0b36: 0x188e, 0x0b37: 0x1898, 0x0b38: 0x070d, 0x0b39: 0x0711, 0x0b3a: 0x1581, 0x0b3b: 0x189d,
+ 0x0b3c: 0x0715, 0x0b3d: 0x18a2, 0x0b3e: 0x1599, 0x0b3f: 0x1599,
+ // Block 0x2d, offset 0xb40
+ 0x0b40: 0x15a1, 0x0b41: 0x18a7, 0x0b42: 0x15b9, 0x0b43: 0x0719, 0x0b44: 0x15c9, 0x0b45: 0x15d5,
+ 0x0b46: 0x15dd, 0x0b47: 0x15e5, 0x0b48: 0x071d, 0x0b49: 0x18ac, 0x0b4a: 0x15f9, 0x0b4b: 0x1615,
+ 0x0b4c: 0x1621, 0x0b4d: 0x0721, 0x0b4e: 0x0725, 0x0b4f: 0x1625, 0x0b50: 0x18b1, 0x0b51: 0x0729,
+ 0x0b52: 0x18b6, 0x0b53: 0x18bb, 0x0b54: 0x18c0, 0x0b55: 0x1649, 0x0b56: 0x072d, 0x0b57: 0x165d,
+ 0x0b58: 0x1665, 0x0b59: 0x1669, 0x0b5a: 0x1671, 0x0b5b: 0x1679, 0x0b5c: 0x1681, 0x0b5d: 0x18ca,
+}
+
+// nfcSparseOffset: 98 entries, 196 bytes
+var nfcSparseOffset = []uint16{0x0, 0x2, 0x6, 0x8, 0x13, 0x23, 0x25, 0x2a, 0x35, 0x44, 0x51, 0x59, 0x5d, 0x62, 0x64, 0x73, 0x7b, 0x82, 0x85, 0x8d, 0x91, 0x95, 0x97, 0x99, 0xa2, 0xa6, 0xad, 0xb2, 0xb5, 0xbf, 0xc1, 0xc8, 0xd0, 0xd3, 0xd5, 0xd7, 0xd9, 0xde, 0xed, 0xf9, 0xfb, 0x101, 0x103, 0x105, 0x107, 0x109, 0x10b, 0x10d, 0x110, 0x113, 0x115, 0x118, 0x11b, 0x11f, 0x128, 0x12a, 0x12d, 0x12f, 0x139, 0x148, 0x14a, 0x158, 0x15b, 0x161, 0x167, 0x172, 0x176, 0x178, 0x17a, 0x17c, 0x17e, 0x180, 0x186, 0x189, 0x18b, 0x18d, 0x18f, 0x192, 0x194, 0x196, 0x198, 0x19a, 0x1a0, 0x1a3, 0x1a5, 0x1a7, 0x1a9, 0x1b7, 0x1c0, 0x1c2, 0x1c4, 0x1ca, 0x1d2, 0x1d9, 0x1dc, 0x1e9, 0x1f3, 0x1f5}
+
+// nfcSparseValues: 503 entries, 2012 bytes
+var nfcSparseValues = [503]valueRange{
+ // Block 0x0, offset 0x1
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8800, lo: 0xa8, hi: 0xa8},
+ // Block 0x1, offset 0x2
+ {value: 0x0091, lo: 0x03},
+ {value: 0x46c8, lo: 0xa0, hi: 0xa1},
+ {value: 0x46fa, lo: 0xaf, hi: 0xb0},
+ {value: 0x8800, lo: 0xb7, hi: 0xb7},
+ // Block 0x2, offset 0x3
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ // Block 0x3, offset 0x4
+ {value: 0x0006, lo: 0x0a},
+ {value: 0x8800, lo: 0x81, hi: 0x81},
+ {value: 0x8800, lo: 0x85, hi: 0x85},
+ {value: 0x8800, lo: 0x89, hi: 0x89},
+ {value: 0x4826, lo: 0x8a, hi: 0x8a},
+ {value: 0x4844, lo: 0x8b, hi: 0x8b},
+ {value: 0x36b1, lo: 0x8c, hi: 0x8c},
+ {value: 0x36c9, lo: 0x8d, hi: 0x8d},
+ {value: 0x485c, lo: 0x8e, hi: 0x8e},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x36e7, lo: 0x93, hi: 0x94},
+ // Block 0x4, offset 0x5
+ {value: 0x0000, lo: 0x0f},
+ {value: 0x8800, lo: 0x83, hi: 0x83},
+ {value: 0x8800, lo: 0x87, hi: 0x87},
+ {value: 0x8800, lo: 0x8b, hi: 0x8b},
+ {value: 0x8800, lo: 0x8d, hi: 0x8d},
+ {value: 0x378f, lo: 0x90, hi: 0x90},
+ {value: 0x379b, lo: 0x91, hi: 0x91},
+ {value: 0x3789, lo: 0x93, hi: 0x93},
+ {value: 0x8800, lo: 0x96, hi: 0x96},
+ {value: 0x3801, lo: 0x97, hi: 0x97},
+ {value: 0x37cb, lo: 0x9c, hi: 0x9c},
+ {value: 0x37b3, lo: 0x9d, hi: 0x9d},
+ {value: 0x37dd, lo: 0x9e, hi: 0x9e},
+ {value: 0x8800, lo: 0xb4, hi: 0xb5},
+ {value: 0x3807, lo: 0xb6, hi: 0xb6},
+ {value: 0x380d, lo: 0xb7, hi: 0xb7},
+ // Block 0x5, offset 0x6
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x83, hi: 0x87},
+ // Block 0x6, offset 0x7
+ {value: 0x0001, lo: 0x04},
+ {value: 0x8018, lo: 0x81, hi: 0x82},
+ {value: 0x80e6, lo: 0x84, hi: 0x84},
+ {value: 0x80dc, lo: 0x85, hi: 0x85},
+ {value: 0x8012, lo: 0x87, hi: 0x87},
+ // Block 0x7, offset 0x8
+ {value: 0x0000, lo: 0x0a},
+ {value: 0x80e6, lo: 0x90, hi: 0x97},
+ {value: 0x801e, lo: 0x98, hi: 0x98},
+ {value: 0x801f, lo: 0x99, hi: 0x99},
+ {value: 0x8020, lo: 0x9a, hi: 0x9a},
+ {value: 0x382b, lo: 0xa2, hi: 0xa2},
+ {value: 0x3831, lo: 0xa3, hi: 0xa3},
+ {value: 0x383d, lo: 0xa4, hi: 0xa4},
+ {value: 0x3837, lo: 0xa5, hi: 0xa5},
+ {value: 0x3843, lo: 0xa6, hi: 0xa6},
+ {value: 0x8800, lo: 0xa7, hi: 0xa7},
+ // Block 0x8, offset 0x9
+ {value: 0x0000, lo: 0x0e},
+ {value: 0x3855, lo: 0x80, hi: 0x80},
+ {value: 0x8800, lo: 0x81, hi: 0x81},
+ {value: 0x3849, lo: 0x82, hi: 0x82},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x384f, lo: 0x93, hi: 0x93},
+ {value: 0x8800, lo: 0x95, hi: 0x95},
+ {value: 0x80e6, lo: 0x96, hi: 0x9c},
+ {value: 0x80e6, lo: 0x9f, hi: 0xa2},
+ {value: 0x80dc, lo: 0xa3, hi: 0xa3},
+ {value: 0x80e6, lo: 0xa4, hi: 0xa4},
+ {value: 0x80e6, lo: 0xa7, hi: 0xa8},
+ {value: 0x80dc, lo: 0xaa, hi: 0xaa},
+ {value: 0x80e6, lo: 0xab, hi: 0xac},
+ {value: 0x80dc, lo: 0xad, hi: 0xad},
+ // Block 0x9, offset 0xa
+ {value: 0x0000, lo: 0x0c},
+ {value: 0x8024, lo: 0x91, hi: 0x91},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb0},
+ {value: 0x80dc, lo: 0xb1, hi: 0xb1},
+ {value: 0x80e6, lo: 0xb2, hi: 0xb3},
+ {value: 0x80dc, lo: 0xb4, hi: 0xb4},
+ {value: 0x80e6, lo: 0xb5, hi: 0xb6},
+ {value: 0x80dc, lo: 0xb7, hi: 0xb9},
+ {value: 0x80e6, lo: 0xba, hi: 0xba},
+ {value: 0x80dc, lo: 0xbb, hi: 0xbc},
+ {value: 0x80e6, lo: 0xbd, hi: 0xbd},
+ {value: 0x80dc, lo: 0xbe, hi: 0xbe},
+ {value: 0x80e6, lo: 0xbf, hi: 0xbf},
+ // Block 0xa, offset 0xb
+ {value: 0x000a, lo: 0x07},
+ {value: 0x80e6, lo: 0x80, hi: 0x80},
+ {value: 0x80e6, lo: 0x81, hi: 0x81},
+ {value: 0x80dc, lo: 0x82, hi: 0x83},
+ {value: 0x80dc, lo: 0x84, hi: 0x85},
+ {value: 0x80dc, lo: 0x86, hi: 0x87},
+ {value: 0x80dc, lo: 0x88, hi: 0x89},
+ {value: 0x80e6, lo: 0x8a, hi: 0x8a},
+ // Block 0xb, offset 0xc
+ {value: 0x0000, lo: 0x03},
+ {value: 0x80e6, lo: 0xab, hi: 0xb1},
+ {value: 0x80dc, lo: 0xb2, hi: 0xb2},
+ {value: 0x80e6, lo: 0xb3, hi: 0xb3},
+ // Block 0xc, offset 0xd
+ {value: 0x0000, lo: 0x04},
+ {value: 0x80e6, lo: 0x96, hi: 0x99},
+ {value: 0x80e6, lo: 0x9b, hi: 0xa3},
+ {value: 0x80e6, lo: 0xa5, hi: 0xa7},
+ {value: 0x80e6, lo: 0xa9, hi: 0xad},
+ // Block 0xd, offset 0xe
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0x99, hi: 0x9b},
+ // Block 0xe, offset 0xf
+ {value: 0x0000, lo: 0x0e},
+ {value: 0x80e6, lo: 0xa4, hi: 0xa5},
+ {value: 0x80dc, lo: 0xa6, hi: 0xa6},
+ {value: 0x80e6, lo: 0xa7, hi: 0xa8},
+ {value: 0x80dc, lo: 0xa9, hi: 0xa9},
+ {value: 0x80e6, lo: 0xaa, hi: 0xac},
+ {value: 0x80dc, lo: 0xad, hi: 0xaf},
+ {value: 0x801b, lo: 0xb0, hi: 0xb0},
+ {value: 0x801c, lo: 0xb1, hi: 0xb1},
+ {value: 0x801d, lo: 0xb2, hi: 0xb2},
+ {value: 0x80e6, lo: 0xb3, hi: 0xb5},
+ {value: 0x80dc, lo: 0xb6, hi: 0xb6},
+ {value: 0x80e6, lo: 0xb7, hi: 0xb8},
+ {value: 0x80dc, lo: 0xb9, hi: 0xba},
+ {value: 0x80e6, lo: 0xbb, hi: 0xbe},
+ // Block 0xf, offset 0x10
+ {value: 0x0000, lo: 0x07},
+ {value: 0x8800, lo: 0xa8, hi: 0xa8},
+ {value: 0x3ec2, lo: 0xa9, hi: 0xa9},
+ {value: 0x8800, lo: 0xb0, hi: 0xb0},
+ {value: 0x3eca, lo: 0xb1, hi: 0xb1},
+ {value: 0x8800, lo: 0xb3, hi: 0xb3},
+ {value: 0x3ed2, lo: 0xb4, hi: 0xb4},
+ {value: 0x8607, lo: 0xbc, hi: 0xbc},
+ // Block 0x10, offset 0x11
+ {value: 0x0008, lo: 0x06},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x80e6, lo: 0x91, hi: 0x91},
+ {value: 0x80dc, lo: 0x92, hi: 0x92},
+ {value: 0x80e6, lo: 0x93, hi: 0x93},
+ {value: 0x80e6, lo: 0x94, hi: 0x94},
+ {value: 0x4502, lo: 0x98, hi: 0x9f},
+ // Block 0x11, offset 0x12
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ {value: 0x8600, lo: 0xbe, hi: 0xbe},
+ // Block 0x12, offset 0x13
+ {value: 0x0007, lo: 0x07},
+ {value: 0x8800, lo: 0x87, hi: 0x87},
+ {value: 0x18cf, lo: 0x8b, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x97, hi: 0x97},
+ {value: 0x4542, lo: 0x9c, hi: 0x9c},
+ {value: 0x454a, lo: 0x9d, hi: 0x9d},
+ {value: 0x4552, lo: 0x9f, hi: 0x9f},
+ // Block 0x13, offset 0x14
+ {value: 0x0000, lo: 0x03},
+ {value: 0x457a, lo: 0xb3, hi: 0xb3},
+ {value: 0x4582, lo: 0xb6, hi: 0xb6},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ // Block 0x14, offset 0x15
+ {value: 0x0008, lo: 0x03},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x455a, lo: 0x99, hi: 0x9b},
+ {value: 0x4572, lo: 0x9e, hi: 0x9e},
+ // Block 0x15, offset 0x16
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ // Block 0x16, offset 0x17
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ // Block 0x17, offset 0x18
+ {value: 0x0000, lo: 0x08},
+ {value: 0x8800, lo: 0x87, hi: 0x87},
+ {value: 0x18e4, lo: 0x88, hi: 0x88},
+ {value: 0x18dd, lo: 0x8b, hi: 0x8b},
+ {value: 0x18eb, lo: 0x8c, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x96, hi: 0x97},
+ {value: 0x458a, lo: 0x9c, hi: 0x9c},
+ {value: 0x4592, lo: 0x9d, hi: 0x9d},
+ // Block 0x18, offset 0x19
+ {value: 0x0000, lo: 0x03},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x18f2, lo: 0x94, hi: 0x94},
+ {value: 0x8600, lo: 0xbe, hi: 0xbe},
+ // Block 0x19, offset 0x1a
+ {value: 0x0000, lo: 0x06},
+ {value: 0x8800, lo: 0x86, hi: 0x87},
+ {value: 0x18f9, lo: 0x8a, hi: 0x8a},
+ {value: 0x1907, lo: 0x8b, hi: 0x8b},
+ {value: 0x1900, lo: 0x8c, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x97, hi: 0x97},
+ // Block 0x1a, offset 0x1b
+ {value: 0x0607, lo: 0x04},
+ {value: 0x8800, lo: 0x86, hi: 0x86},
+ {value: 0x3eda, lo: 0x88, hi: 0x88},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8054, lo: 0x95, hi: 0x96},
+ // Block 0x1b, offset 0x1c
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ {value: 0x8800, lo: 0xbf, hi: 0xbf},
+ // Block 0x1c, offset 0x1d
+ {value: 0x0000, lo: 0x09},
+ {value: 0x190e, lo: 0x80, hi: 0x80},
+ {value: 0x8600, lo: 0x82, hi: 0x82},
+ {value: 0x8800, lo: 0x86, hi: 0x86},
+ {value: 0x1915, lo: 0x87, hi: 0x87},
+ {value: 0x191c, lo: 0x88, hi: 0x88},
+ {value: 0x2e66, lo: 0x8a, hi: 0x8a},
+ {value: 0x19a5, lo: 0x8b, hi: 0x8b},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x95, hi: 0x96},
+ // Block 0x1d, offset 0x1e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8600, lo: 0xbe, hi: 0xbe},
+ // Block 0x1e, offset 0x1f
+ {value: 0x0000, lo: 0x06},
+ {value: 0x8800, lo: 0x86, hi: 0x87},
+ {value: 0x1923, lo: 0x8a, hi: 0x8a},
+ {value: 0x1931, lo: 0x8b, hi: 0x8b},
+ {value: 0x192a, lo: 0x8c, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x97, hi: 0x97},
+ // Block 0x1f, offset 0x20
+ {value: 0x0007, lo: 0x07},
+ {value: 0x8609, lo: 0x8a, hi: 0x8a},
+ {value: 0x8600, lo: 0x8f, hi: 0x8f},
+ {value: 0x8800, lo: 0x99, hi: 0x99},
+ {value: 0x3ee2, lo: 0x9a, hi: 0x9a},
+ {value: 0x2e6d, lo: 0x9c, hi: 0x9d},
+ {value: 0x1938, lo: 0x9e, hi: 0x9e},
+ {value: 0x8600, lo: 0x9f, hi: 0x9f},
+ // Block 0x20, offset 0x21
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8067, lo: 0xb8, hi: 0xb9},
+ {value: 0x8009, lo: 0xba, hi: 0xba},
+ // Block 0x21, offset 0x22
+ {value: 0x0000, lo: 0x01},
+ {value: 0x806b, lo: 0x88, hi: 0x8b},
+ // Block 0x22, offset 0x23
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8076, lo: 0xb8, hi: 0xb9},
+ // Block 0x23, offset 0x24
+ {value: 0x0000, lo: 0x01},
+ {value: 0x807a, lo: 0x88, hi: 0x8b},
+ // Block 0x24, offset 0x25
+ {value: 0x0000, lo: 0x04},
+ {value: 0x80dc, lo: 0x98, hi: 0x99},
+ {value: 0x80dc, lo: 0xb5, hi: 0xb5},
+ {value: 0x80dc, lo: 0xb7, hi: 0xb7},
+ {value: 0x80d8, lo: 0xb9, hi: 0xb9},
+ // Block 0x25, offset 0x26
+ {value: 0x0000, lo: 0x0e},
+ {value: 0x2786, lo: 0x83, hi: 0x83},
+ {value: 0x278d, lo: 0x8d, hi: 0x8d},
+ {value: 0x2794, lo: 0x92, hi: 0x92},
+ {value: 0x279b, lo: 0x97, hi: 0x97},
+ {value: 0x27a2, lo: 0x9c, hi: 0x9c},
+ {value: 0x277f, lo: 0xa9, hi: 0xa9},
+ {value: 0x8081, lo: 0xb1, hi: 0xb1},
+ {value: 0x8082, lo: 0xb2, hi: 0xb2},
+ {value: 0x49b6, lo: 0xb3, hi: 0xb3},
+ {value: 0x8084, lo: 0xb4, hi: 0xb4},
+ {value: 0x49bf, lo: 0xb5, hi: 0xb5},
+ {value: 0x459a, lo: 0xb6, hi: 0xb6},
+ {value: 0x45a2, lo: 0xb8, hi: 0xb8},
+ {value: 0x8082, lo: 0xba, hi: 0xbd},
+ // Block 0x26, offset 0x27
+ {value: 0x0000, lo: 0x0b},
+ {value: 0x8082, lo: 0x80, hi: 0x80},
+ {value: 0x49c8, lo: 0x81, hi: 0x81},
+ {value: 0x80e6, lo: 0x82, hi: 0x83},
+ {value: 0x8009, lo: 0x84, hi: 0x84},
+ {value: 0x80e6, lo: 0x86, hi: 0x87},
+ {value: 0x27b0, lo: 0x93, hi: 0x93},
+ {value: 0x27b7, lo: 0x9d, hi: 0x9d},
+ {value: 0x27be, lo: 0xa2, hi: 0xa2},
+ {value: 0x27c5, lo: 0xa7, hi: 0xa7},
+ {value: 0x27cc, lo: 0xac, hi: 0xac},
+ {value: 0x27a9, lo: 0xb9, hi: 0xb9},
+ // Block 0x27, offset 0x28
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0x86, hi: 0x86},
+ // Block 0x28, offset 0x29
+ {value: 0x0000, lo: 0x05},
+ {value: 0x8800, lo: 0xa5, hi: 0xa5},
+ {value: 0x193f, lo: 0xa6, hi: 0xa6},
+ {value: 0x8600, lo: 0xae, hi: 0xae},
+ {value: 0x8007, lo: 0xb7, hi: 0xb7},
+ {value: 0x8009, lo: 0xb9, hi: 0xba},
+ // Block 0x29, offset 0x2a
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0x8d, hi: 0x8d},
+ // Block 0x2a, offset 0x2b
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8800, lo: 0x80, hi: 0x92},
+ // Block 0x2b, offset 0x2c
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8e00, lo: 0xa1, hi: 0xb5},
+ // Block 0x2c, offset 0x2d
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8600, lo: 0xa8, hi: 0xbf},
+ // Block 0x2d, offset 0x2e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8600, lo: 0x80, hi: 0x82},
+ // Block 0x2e, offset 0x2f
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x9d, hi: 0x9f},
+ // Block 0x2f, offset 0x30
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0x94, hi: 0x94},
+ {value: 0x8009, lo: 0xb4, hi: 0xb4},
+ // Block 0x30, offset 0x31
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0x92, hi: 0x92},
+ {value: 0x80e6, lo: 0x9d, hi: 0x9d},
+ // Block 0x31, offset 0x32
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e4, lo: 0xa9, hi: 0xa9},
+ // Block 0x32, offset 0x33
+ {value: 0x0008, lo: 0x02},
+ {value: 0x80de, lo: 0xb9, hi: 0xba},
+ {value: 0x80dc, lo: 0xbb, hi: 0xbb},
+ // Block 0x33, offset 0x34
+ {value: 0x0000, lo: 0x02},
+ {value: 0x80e6, lo: 0x97, hi: 0x97},
+ {value: 0x80dc, lo: 0x98, hi: 0x98},
+ // Block 0x34, offset 0x35
+ {value: 0x0000, lo: 0x03},
+ {value: 0x8009, lo: 0xa0, hi: 0xa0},
+ {value: 0x80e6, lo: 0xb5, hi: 0xbc},
+ {value: 0x80dc, lo: 0xbf, hi: 0xbf},
+ // Block 0x35, offset 0x36
+ {value: 0x0000, lo: 0x08},
+ {value: 0x197e, lo: 0x80, hi: 0x80},
+ {value: 0x1985, lo: 0x81, hi: 0x81},
+ {value: 0x8800, lo: 0x82, hi: 0x82},
+ {value: 0x198c, lo: 0x83, hi: 0x83},
+ {value: 0x8009, lo: 0x84, hi: 0x84},
+ {value: 0x80e6, lo: 0xab, hi: 0xab},
+ {value: 0x80dc, lo: 0xac, hi: 0xac},
+ {value: 0x80e6, lo: 0xad, hi: 0xb3},
+ // Block 0x36, offset 0x37
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0xaa, hi: 0xab},
+ // Block 0x37, offset 0x38
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8007, lo: 0xa6, hi: 0xa6},
+ {value: 0x8009, lo: 0xb2, hi: 0xb3},
+ // Block 0x38, offset 0x39
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8007, lo: 0xb7, hi: 0xb7},
+ // Block 0x39, offset 0x3a
+ {value: 0x0000, lo: 0x09},
+ {value: 0x80e6, lo: 0x90, hi: 0x92},
+ {value: 0x8001, lo: 0x94, hi: 0x94},
+ {value: 0x80dc, lo: 0x95, hi: 0x99},
+ {value: 0x80e6, lo: 0x9a, hi: 0x9b},
+ {value: 0x80dc, lo: 0x9c, hi: 0x9f},
+ {value: 0x80e6, lo: 0xa0, hi: 0xa0},
+ {value: 0x8001, lo: 0xa2, hi: 0xa8},
+ {value: 0x80dc, lo: 0xad, hi: 0xad},
+ {value: 0x80e6, lo: 0xb4, hi: 0xb4},
+ // Block 0x3a, offset 0x3b
+ {value: 0x0000, lo: 0x0e},
+ {value: 0x80e6, lo: 0x80, hi: 0x81},
+ {value: 0x80dc, lo: 0x82, hi: 0x82},
+ {value: 0x80e6, lo: 0x83, hi: 0x89},
+ {value: 0x80dc, lo: 0x8a, hi: 0x8a},
+ {value: 0x80e6, lo: 0x8b, hi: 0x8c},
+ {value: 0x80ea, lo: 0x8d, hi: 0x8d},
+ {value: 0x80d6, lo: 0x8e, hi: 0x8e},
+ {value: 0x80dc, lo: 0x8f, hi: 0x8f},
+ {value: 0x80ca, lo: 0x90, hi: 0x90},
+ {value: 0x80e6, lo: 0x91, hi: 0xa6},
+ {value: 0x80e9, lo: 0xbc, hi: 0xbc},
+ {value: 0x80dc, lo: 0xbd, hi: 0xbd},
+ {value: 0x80e6, lo: 0xbe, hi: 0xbe},
+ {value: 0x80dc, lo: 0xbf, hi: 0xbf},
+ // Block 0x3b, offset 0x3c
+ {value: 0x0004, lo: 0x01},
+ {value: 0x04a5, lo: 0x80, hi: 0x81},
+ // Block 0x3c, offset 0x3d
+ {value: 0x0000, lo: 0x0d},
+ {value: 0x80e6, lo: 0x90, hi: 0x91},
+ {value: 0x8001, lo: 0x92, hi: 0x93},
+ {value: 0x80e6, lo: 0x94, hi: 0x97},
+ {value: 0x8001, lo: 0x98, hi: 0x9a},
+ {value: 0x80e6, lo: 0x9b, hi: 0x9c},
+ {value: 0x80e6, lo: 0xa1, hi: 0xa1},
+ {value: 0x8001, lo: 0xa5, hi: 0xa6},
+ {value: 0x80e6, lo: 0xa7, hi: 0xa7},
+ {value: 0x80dc, lo: 0xa8, hi: 0xa8},
+ {value: 0x80e6, lo: 0xa9, hi: 0xa9},
+ {value: 0x8001, lo: 0xaa, hi: 0xab},
+ {value: 0x80dc, lo: 0xac, hi: 0xaf},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb0},
+ // Block 0x3d, offset 0x3e
+ {value: 0x4261, lo: 0x02},
+ {value: 0x01b8, lo: 0xa6, hi: 0xa6},
+ {value: 0x0057, lo: 0xaa, hi: 0xab},
+ // Block 0x3e, offset 0x3f
+ {value: 0x0007, lo: 0x05},
+ {value: 0x8800, lo: 0x90, hi: 0x90},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x8800, lo: 0x94, hi: 0x94},
+ {value: 0x3ba3, lo: 0x9a, hi: 0x9b},
+ {value: 0x3bb1, lo: 0xae, hi: 0xae},
+ // Block 0x3f, offset 0x40
+ {value: 0x000e, lo: 0x05},
+ {value: 0x3bb8, lo: 0x8d, hi: 0x8e},
+ {value: 0x3bbf, lo: 0x8f, hi: 0x8f},
+ {value: 0x8800, lo: 0x90, hi: 0x90},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x8800, lo: 0x94, hi: 0x94},
+ // Block 0x40, offset 0x41
+ {value: 0x4c1e, lo: 0x0a},
+ {value: 0x8800, lo: 0x83, hi: 0x83},
+ {value: 0x3bcd, lo: 0x84, hi: 0x84},
+ {value: 0x8800, lo: 0x88, hi: 0x88},
+ {value: 0x3bd4, lo: 0x89, hi: 0x89},
+ {value: 0x8800, lo: 0x8b, hi: 0x8b},
+ {value: 0x3bdb, lo: 0x8c, hi: 0x8c},
+ {value: 0x8800, lo: 0xa3, hi: 0xa3},
+ {value: 0x3be2, lo: 0xa4, hi: 0xa5},
+ {value: 0x3be9, lo: 0xa6, hi: 0xa6},
+ {value: 0x8800, lo: 0xbc, hi: 0xbc},
+ // Block 0x41, offset 0x42
+ {value: 0x0007, lo: 0x03},
+ {value: 0x3c52, lo: 0xa0, hi: 0xa1},
+ {value: 0x3c7c, lo: 0xa2, hi: 0xa3},
+ {value: 0x3ca6, lo: 0xaa, hi: 0xad},
+ // Block 0x42, offset 0x43
+ {value: 0x0004, lo: 0x01},
+ {value: 0x04fd, lo: 0xa9, hi: 0xaa},
+ // Block 0x43, offset 0x44
+ {value: 0x0000, lo: 0x01},
+ {value: 0x44c3, lo: 0x9c, hi: 0x9c},
+ // Block 0x44, offset 0x45
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0xaf, hi: 0xb1},
+ // Block 0x45, offset 0x46
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0xbf, hi: 0xbf},
+ // Block 0x46, offset 0x47
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0xa0, hi: 0xbf},
+ // Block 0x47, offset 0x48
+ {value: 0x0000, lo: 0x05},
+ {value: 0x80da, lo: 0xaa, hi: 0xaa},
+ {value: 0x80e4, lo: 0xab, hi: 0xab},
+ {value: 0x80e8, lo: 0xac, hi: 0xac},
+ {value: 0x80de, lo: 0xad, hi: 0xad},
+ {value: 0x80e0, lo: 0xae, hi: 0xaf},
+ // Block 0x48, offset 0x49
+ {value: 0x0000, lo: 0x02},
+ {value: 0x80e6, lo: 0xaf, hi: 0xaf},
+ {value: 0x80e6, lo: 0xb4, hi: 0xbd},
+ // Block 0x49, offset 0x4a
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x9f, hi: 0x9f},
+ // Block 0x4a, offset 0x4b
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb1},
+ // Block 0x4b, offset 0x4c
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x86, hi: 0x86},
+ // Block 0x4c, offset 0x4d
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0x84, hi: 0x84},
+ {value: 0x80e6, lo: 0xa0, hi: 0xb1},
+ // Block 0x4d, offset 0x4e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0xab, hi: 0xad},
+ // Block 0x4e, offset 0x4f
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x93, hi: 0x93},
+ // Block 0x4f, offset 0x50
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8007, lo: 0xb3, hi: 0xb3},
+ // Block 0x50, offset 0x51
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x80, hi: 0x80},
+ // Block 0x51, offset 0x52
+ {value: 0x0000, lo: 0x05},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb0},
+ {value: 0x80e6, lo: 0xb2, hi: 0xb3},
+ {value: 0x80dc, lo: 0xb4, hi: 0xb4},
+ {value: 0x80e6, lo: 0xb7, hi: 0xb8},
+ {value: 0x80e6, lo: 0xbe, hi: 0xbf},
+ // Block 0x52, offset 0x53
+ {value: 0x0000, lo: 0x02},
+ {value: 0x80e6, lo: 0x81, hi: 0x81},
+ {value: 0x8009, lo: 0xb6, hi: 0xb6},
+ // Block 0x53, offset 0x54
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0xad, hi: 0xad},
+ // Block 0x54, offset 0x55
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8100, lo: 0x80, hi: 0xbf},
+ // Block 0x55, offset 0x56
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8100, lo: 0x80, hi: 0xa3},
+ // Block 0x56, offset 0x57
+ {value: 0x0006, lo: 0x0d},
+ {value: 0x4376, lo: 0x9d, hi: 0x9d},
+ {value: 0x801a, lo: 0x9e, hi: 0x9e},
+ {value: 0x43e8, lo: 0x9f, hi: 0x9f},
+ {value: 0x43d6, lo: 0xaa, hi: 0xab},
+ {value: 0x44da, lo: 0xac, hi: 0xac},
+ {value: 0x44e2, lo: 0xad, hi: 0xad},
+ {value: 0x432e, lo: 0xae, hi: 0xb1},
+ {value: 0x434c, lo: 0xb2, hi: 0xb4},
+ {value: 0x4364, lo: 0xb5, hi: 0xb6},
+ {value: 0x4370, lo: 0xb8, hi: 0xb8},
+ {value: 0x437c, lo: 0xb9, hi: 0xbb},
+ {value: 0x4394, lo: 0xbc, hi: 0xbc},
+ {value: 0x439a, lo: 0xbe, hi: 0xbe},
+ // Block 0x57, offset 0x58
+ {value: 0x0006, lo: 0x08},
+ {value: 0x43a0, lo: 0x80, hi: 0x81},
+ {value: 0x43ac, lo: 0x83, hi: 0x84},
+ {value: 0x43be, lo: 0x86, hi: 0x89},
+ {value: 0x43e2, lo: 0x8a, hi: 0x8a},
+ {value: 0x435e, lo: 0x8b, hi: 0x8b},
+ {value: 0x4346, lo: 0x8c, hi: 0x8c},
+ {value: 0x438e, lo: 0x8d, hi: 0x8d},
+ {value: 0x43b8, lo: 0x8e, hi: 0x8e},
+ // Block 0x58, offset 0x59
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0xa0, hi: 0xa6},
+ // Block 0x59, offset 0x5a
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0xbd, hi: 0xbd},
+ // Block 0x5a, offset 0x5b
+ {value: 0x00db, lo: 0x05},
+ {value: 0x80dc, lo: 0x8d, hi: 0x8d},
+ {value: 0x80e6, lo: 0x8f, hi: 0x8f},
+ {value: 0x80e6, lo: 0xb8, hi: 0xb8},
+ {value: 0x8001, lo: 0xb9, hi: 0xba},
+ {value: 0x8009, lo: 0xbf, hi: 0xbf},
+ // Block 0x5b, offset 0x5c
+ {value: 0x05fe, lo: 0x07},
+ {value: 0x8800, lo: 0x99, hi: 0x99},
+ {value: 0x4222, lo: 0x9a, hi: 0x9a},
+ {value: 0x8800, lo: 0x9b, hi: 0x9b},
+ {value: 0x422c, lo: 0x9c, hi: 0x9c},
+ {value: 0x8800, lo: 0xa5, hi: 0xa5},
+ {value: 0x4236, lo: 0xab, hi: 0xab},
+ {value: 0x8009, lo: 0xb9, hi: 0xba},
+ // Block 0x5c, offset 0x5d
+ {value: 0x0000, lo: 0x06},
+ {value: 0x80e6, lo: 0x80, hi: 0x82},
+ {value: 0x8600, lo: 0xa7, hi: 0xa7},
+ {value: 0x1993, lo: 0xae, hi: 0xae},
+ {value: 0x199c, lo: 0xaf, hi: 0xaf},
+ {value: 0x8800, lo: 0xb1, hi: 0xb2},
+ {value: 0x8009, lo: 0xb3, hi: 0xb4},
+ // Block 0x5d, offset 0x5e
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0xb6, hi: 0xb6},
+ {value: 0x8007, lo: 0xb7, hi: 0xb7},
+ // Block 0x5e, offset 0x5f
+ {value: 0x0000, lo: 0x0c},
+ {value: 0x45b2, lo: 0x9e, hi: 0x9e},
+ {value: 0x45bc, lo: 0x9f, hi: 0x9f},
+ {value: 0x45f0, lo: 0xa0, hi: 0xa0},
+ {value: 0x45fe, lo: 0xa1, hi: 0xa1},
+ {value: 0x460c, lo: 0xa2, hi: 0xa2},
+ {value: 0x461a, lo: 0xa3, hi: 0xa3},
+ {value: 0x4628, lo: 0xa4, hi: 0xa4},
+ {value: 0x80d8, lo: 0xa5, hi: 0xa6},
+ {value: 0x8001, lo: 0xa7, hi: 0xa9},
+ {value: 0x80e2, lo: 0xad, hi: 0xad},
+ {value: 0x80d8, lo: 0xae, hi: 0xb2},
+ {value: 0x80dc, lo: 0xbb, hi: 0xbf},
+ // Block 0x5f, offset 0x60
+ {value: 0x0000, lo: 0x09},
+ {value: 0x80dc, lo: 0x80, hi: 0x82},
+ {value: 0x80e6, lo: 0x85, hi: 0x89},
+ {value: 0x80dc, lo: 0x8a, hi: 0x8b},
+ {value: 0x80e6, lo: 0xaa, hi: 0xad},
+ {value: 0x45c6, lo: 0xbb, hi: 0xbb},
+ {value: 0x45d0, lo: 0xbc, hi: 0xbc},
+ {value: 0x4636, lo: 0xbd, hi: 0xbd},
+ {value: 0x4652, lo: 0xbe, hi: 0xbe},
+ {value: 0x4644, lo: 0xbf, hi: 0xbf},
+ // Block 0x60, offset 0x61
+ {value: 0x0000, lo: 0x01},
+ {value: 0x4660, lo: 0x80, hi: 0x80},
+ // Block 0x61, offset 0x62
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x82, hi: 0x84},
+}
+
+// nfcLookup: 1088 bytes
+// Block 0 is the null block.
+var nfcLookup = [1088]uint8{
+ // Block 0x0, offset 0x0
+ // Block 0x1, offset 0x40
+ // Block 0x2, offset 0x80
+ // Block 0x3, offset 0xc0
+ 0x0c2: 0x2c, 0x0c3: 0x01, 0x0c4: 0x02, 0x0c5: 0x03, 0x0c6: 0x2d, 0x0c7: 0x04,
+ 0x0c8: 0x05, 0x0ca: 0x2e, 0x0cc: 0x06, 0x0cd: 0x07, 0x0ce: 0x08, 0x0cf: 0x2f,
+ 0x0d0: 0x09, 0x0d1: 0x30, 0x0d2: 0x31, 0x0d3: 0x0a, 0x0d6: 0x0b, 0x0d7: 0x32,
+ 0x0d8: 0x33, 0x0d9: 0x0c, 0x0db: 0x34, 0x0dc: 0x35, 0x0dd: 0x36, 0x0df: 0x37,
+ 0x0e0: 0x02, 0x0e1: 0x03, 0x0e2: 0x04, 0x0e3: 0x05,
+ 0x0ea: 0x06, 0x0eb: 0x07, 0x0ec: 0x07, 0x0ed: 0x08, 0x0ef: 0x09,
+ 0x0f0: 0x0e,
+ // Block 0x4, offset 0x100
+ 0x120: 0x38, 0x121: 0x39, 0x123: 0x3a, 0x124: 0x3b, 0x125: 0x3c, 0x126: 0x3d, 0x127: 0x3e,
+ 0x128: 0x3f, 0x129: 0x40, 0x12a: 0x41, 0x12b: 0x42, 0x12c: 0x3d, 0x12d: 0x43, 0x12e: 0x44, 0x12f: 0x45,
+ 0x131: 0x46, 0x132: 0x47, 0x133: 0x48, 0x134: 0x49, 0x135: 0x4a, 0x137: 0x4b,
+ 0x138: 0x4c, 0x139: 0x4d, 0x13a: 0x4e, 0x13b: 0x4f, 0x13c: 0x50, 0x13d: 0x51, 0x13e: 0x52, 0x13f: 0x53,
+ // Block 0x5, offset 0x140
+ 0x140: 0x54, 0x142: 0x55, 0x144: 0x56, 0x145: 0x57, 0x146: 0x58, 0x147: 0x59,
+ 0x14d: 0x5a,
+ 0x15c: 0x5b, 0x15f: 0x5c,
+ 0x162: 0x5d, 0x164: 0x5e,
+ 0x168: 0x5f, 0x169: 0x60, 0x16c: 0x0d, 0x16d: 0x61, 0x16e: 0x62, 0x16f: 0x63,
+ 0x170: 0x64, 0x173: 0x65, 0x177: 0x66,
+ 0x178: 0x0e, 0x179: 0x0f, 0x17a: 0x10, 0x17b: 0x11, 0x17c: 0x12, 0x17d: 0x13, 0x17e: 0x14, 0x17f: 0x15,
+ // Block 0x6, offset 0x180
+ 0x180: 0x67, 0x183: 0x68, 0x184: 0x69, 0x186: 0x6a, 0x187: 0x6b,
+ 0x188: 0x6c, 0x189: 0x16, 0x18a: 0x17, 0x18b: 0x6d, 0x18c: 0x6e,
+ 0x1ab: 0x6f,
+ 0x1b3: 0x70, 0x1b5: 0x71, 0x1b7: 0x72,
+ // Block 0x7, offset 0x1c0
+ 0x1c0: 0x73, 0x1c1: 0x18, 0x1c2: 0x19, 0x1c3: 0x1a,
+ // Block 0x8, offset 0x200
+ 0x219: 0x74, 0x21a: 0x75, 0x21b: 0x76,
+ 0x220: 0x77, 0x223: 0x78, 0x224: 0x79, 0x225: 0x7a, 0x226: 0x7b, 0x227: 0x7c,
+ 0x22a: 0x7d, 0x22b: 0x7e, 0x22f: 0x7f,
+ 0x230: 0x80, 0x231: 0x80, 0x232: 0x80, 0x233: 0x80, 0x234: 0x80, 0x235: 0x80, 0x236: 0x80, 0x237: 0x80,
+ 0x238: 0x80, 0x239: 0x80, 0x23a: 0x80, 0x23b: 0x80, 0x23c: 0x80, 0x23d: 0x80, 0x23e: 0x80, 0x23f: 0x80,
+ // Block 0x9, offset 0x240
+ 0x240: 0x80, 0x241: 0x80, 0x242: 0x80, 0x243: 0x80, 0x244: 0x80, 0x245: 0x80, 0x246: 0x80, 0x247: 0x80,
+ 0x248: 0x80, 0x249: 0x80, 0x24a: 0x80, 0x24b: 0x80, 0x24c: 0x80, 0x24d: 0x80, 0x24e: 0x80, 0x24f: 0x80,
+ 0x250: 0x80, 0x251: 0x80, 0x252: 0x80, 0x253: 0x80, 0x254: 0x80, 0x255: 0x80, 0x256: 0x80, 0x257: 0x80,
+ 0x258: 0x80, 0x259: 0x80, 0x25a: 0x80, 0x25b: 0x80, 0x25c: 0x80, 0x25d: 0x80, 0x25e: 0x80, 0x25f: 0x80,
+ 0x260: 0x80, 0x261: 0x80, 0x262: 0x80, 0x263: 0x80, 0x264: 0x80, 0x265: 0x80, 0x266: 0x80, 0x267: 0x80,
+ 0x268: 0x80, 0x269: 0x80, 0x26a: 0x80, 0x26b: 0x80, 0x26c: 0x80, 0x26d: 0x80, 0x26e: 0x80, 0x26f: 0x80,
+ 0x270: 0x80, 0x271: 0x80, 0x272: 0x80, 0x273: 0x80, 0x274: 0x80, 0x275: 0x80, 0x276: 0x80, 0x277: 0x80,
+ 0x278: 0x80, 0x279: 0x80, 0x27a: 0x80, 0x27b: 0x80, 0x27c: 0x80, 0x27d: 0x80, 0x27e: 0x80, 0x27f: 0x80,
+ // Block 0xa, offset 0x280
+ 0x280: 0x80, 0x281: 0x80, 0x282: 0x80, 0x283: 0x80, 0x284: 0x80, 0x285: 0x80, 0x286: 0x80, 0x287: 0x80,
+ 0x288: 0x80, 0x289: 0x80, 0x28a: 0x80, 0x28b: 0x80, 0x28c: 0x80, 0x28d: 0x80, 0x28e: 0x80, 0x28f: 0x80,
+ 0x290: 0x80, 0x291: 0x80, 0x292: 0x80, 0x293: 0x80, 0x294: 0x80, 0x295: 0x80, 0x296: 0x80, 0x297: 0x80,
+ 0x298: 0x80, 0x299: 0x80, 0x29a: 0x80, 0x29b: 0x80, 0x29c: 0x80, 0x29d: 0x80, 0x29e: 0x81,
+ // Block 0xb, offset 0x2c0
+ 0x2e4: 0x1b, 0x2e5: 0x1c, 0x2e6: 0x1d, 0x2e7: 0x1e,
+ 0x2e8: 0x1f, 0x2e9: 0x20, 0x2ea: 0x21, 0x2eb: 0x22, 0x2ec: 0x82, 0x2ed: 0x83,
+ 0x2f8: 0x84,
+ // Block 0xc, offset 0x300
+ 0x307: 0x85,
+ 0x328: 0x86,
+ // Block 0xd, offset 0x340
+ 0x341: 0x77, 0x342: 0x87, 0x344: 0x88, 0x347: 0x7c,
+ 0x35a: 0x89,
+ // Block 0xe, offset 0x380
+ 0x385: 0x8a, 0x386: 0x8b, 0x387: 0x8c,
+ 0x389: 0x8d,
+ // Block 0xf, offset 0x3c0
+ 0x3e0: 0x23, 0x3e1: 0x24, 0x3e2: 0x25, 0x3e3: 0x26, 0x3e4: 0x27, 0x3e5: 0x28, 0x3e6: 0x29, 0x3e7: 0x2a,
+ 0x3e8: 0x2b,
+ // Block 0x10, offset 0x400
+ 0x410: 0x0a, 0x411: 0x0b,
+ 0x41d: 0x0c,
+ 0x42f: 0x0d,
+}
+
+var nfcTrie = trie{nfcLookup[:], nfcValues[:], nfcSparseValues[:], nfcSparseOffset[:], 44}
+
+// nfkcValues: 5760 entries, 11520 bytes
+// Block 2 is the null block.
+var nfkcValues = [5760]uint16{
+ // Block 0x0, offset 0x0
+ 0x003c: 0x8800, 0x003d: 0x8800, 0x003e: 0x8800,
+ // Block 0x1, offset 0x40
+ 0x0041: 0x8800, 0x0042: 0x8800, 0x0043: 0x8800, 0x0044: 0x8800, 0x0045: 0x8800,
+ 0x0046: 0x8800, 0x0047: 0x8800, 0x0048: 0x8800, 0x0049: 0x8800, 0x004a: 0x8800, 0x004b: 0x8800,
+ 0x004c: 0x8800, 0x004d: 0x8800, 0x004e: 0x8800, 0x004f: 0x8800, 0x0050: 0x8800,
+ 0x0052: 0x8800, 0x0053: 0x8800, 0x0054: 0x8800, 0x0055: 0x8800, 0x0056: 0x8800, 0x0057: 0x8800,
+ 0x0058: 0x8800, 0x0059: 0x8800, 0x005a: 0x8800,
+ 0x0061: 0x8800, 0x0062: 0x8800, 0x0063: 0x8800,
+ 0x0064: 0x8800, 0x0065: 0x8800, 0x0066: 0x8800, 0x0067: 0x8800, 0x0068: 0x8800, 0x0069: 0x8800,
+ 0x006a: 0x8800, 0x006b: 0x8800, 0x006c: 0x8800, 0x006d: 0x8800, 0x006e: 0x8800, 0x006f: 0x8800,
+ 0x0070: 0x8800, 0x0072: 0x8800, 0x0073: 0x8800, 0x0074: 0x8800, 0x0075: 0x8800,
+ 0x0076: 0x8800, 0x0077: 0x8800, 0x0078: 0x8800, 0x0079: 0x8800, 0x007a: 0x8800,
+ // Block 0x2, offset 0x80
+ // Block 0x3, offset 0xc0
+ 0x00c0: 0x2f59, 0x00c1: 0x2f5e, 0x00c2: 0x466e, 0x00c3: 0x2f63, 0x00c4: 0x467d, 0x00c5: 0x4682,
+ 0x00c6: 0x8800, 0x00c7: 0x468c, 0x00c8: 0x2fcc, 0x00c9: 0x2fd1, 0x00ca: 0x4691, 0x00cb: 0x2fe5,
+ 0x00cc: 0x3058, 0x00cd: 0x305d, 0x00ce: 0x3062, 0x00cf: 0x46a5, 0x00d1: 0x30ee,
+ 0x00d2: 0x3111, 0x00d3: 0x3116, 0x00d4: 0x46af, 0x00d5: 0x46b4, 0x00d6: 0x46c3,
+ 0x00d8: 0x8800, 0x00d9: 0x319d, 0x00da: 0x31a2, 0x00db: 0x31a7, 0x00dc: 0x46f5, 0x00dd: 0x321f,
+ 0x00e0: 0x3265, 0x00e1: 0x326a, 0x00e2: 0x46ff, 0x00e3: 0x326f,
+ 0x00e4: 0x470e, 0x00e5: 0x4713, 0x00e6: 0x8800, 0x00e7: 0x471d, 0x00e8: 0x32d8, 0x00e9: 0x32dd,
+ 0x00ea: 0x4722, 0x00eb: 0x32f1, 0x00ec: 0x3369, 0x00ed: 0x336e, 0x00ee: 0x3373, 0x00ef: 0x4736,
+ 0x00f1: 0x33ff, 0x00f2: 0x3422, 0x00f3: 0x3427, 0x00f4: 0x4740, 0x00f5: 0x4745,
+ 0x00f6: 0x4754, 0x00f8: 0x8800, 0x00f9: 0x34b3, 0x00fa: 0x34b8, 0x00fb: 0x34bd,
+ 0x00fc: 0x4786, 0x00fd: 0x353a, 0x00ff: 0x3553,
+ // Block 0x4, offset 0x100
+ 0x0100: 0x2f68, 0x0101: 0x3274, 0x0102: 0x4673, 0x0103: 0x4704, 0x0104: 0x2f86, 0x0105: 0x3292,
+ 0x0106: 0x2f9a, 0x0107: 0x32a6, 0x0108: 0x2f9f, 0x0109: 0x32ab, 0x010a: 0x2fa4, 0x010b: 0x32b0,
+ 0x010c: 0x2fa9, 0x010d: 0x32b5, 0x010e: 0x2fb3, 0x010f: 0x32bf,
+ 0x0112: 0x4696, 0x0113: 0x4727, 0x0114: 0x2fdb, 0x0115: 0x32e7, 0x0116: 0x2fe0, 0x0117: 0x32ec,
+ 0x0118: 0x2ffe, 0x0119: 0x330a, 0x011a: 0x2fef, 0x011b: 0x32fb, 0x011c: 0x3017, 0x011d: 0x3323,
+ 0x011e: 0x3021, 0x011f: 0x332d, 0x0120: 0x3026, 0x0121: 0x3332, 0x0122: 0x3030, 0x0123: 0x333c,
+ 0x0124: 0x3035, 0x0125: 0x3341, 0x0128: 0x3067, 0x0129: 0x3378,
+ 0x012a: 0x306c, 0x012b: 0x337d, 0x012c: 0x3071, 0x012d: 0x3382, 0x012e: 0x3094, 0x012f: 0x33a0,
+ 0x0130: 0x3076, 0x0132: 0x1a9f, 0x0133: 0x1b29, 0x0134: 0x309e, 0x0135: 0x33aa,
+ 0x0136: 0x30b2, 0x0137: 0x33c3, 0x0139: 0x30bc, 0x013a: 0x33cd, 0x013b: 0x30c6,
+ 0x013c: 0x33d7, 0x013d: 0x30c1, 0x013e: 0x33d2, 0x013f: 0x1cee,
+ // Block 0x5, offset 0x140
+ 0x0140: 0x1d76, 0x0143: 0x30e9, 0x0144: 0x33fa, 0x0145: 0x3102,
+ 0x0146: 0x3413, 0x0147: 0x30f8, 0x0148: 0x3409, 0x0149: 0x1d9e,
+ 0x014c: 0x46b9, 0x014d: 0x474a, 0x014e: 0x311b, 0x014f: 0x342c, 0x0150: 0x3125, 0x0151: 0x3436,
+ 0x0154: 0x3143, 0x0155: 0x3454, 0x0156: 0x315c, 0x0157: 0x346d,
+ 0x0158: 0x314d, 0x0159: 0x345e, 0x015a: 0x46dc, 0x015b: 0x476d, 0x015c: 0x3166, 0x015d: 0x3477,
+ 0x015e: 0x3175, 0x015f: 0x3486, 0x0160: 0x46e1, 0x0161: 0x4772, 0x0162: 0x318e, 0x0163: 0x34a4,
+ 0x0164: 0x317f, 0x0165: 0x3495, 0x0168: 0x46eb, 0x0169: 0x477c,
+ 0x016a: 0x46f0, 0x016b: 0x4781, 0x016c: 0x31ac, 0x016d: 0x34c2, 0x016e: 0x31b6, 0x016f: 0x34cc,
+ 0x0170: 0x31bb, 0x0171: 0x34d1, 0x0172: 0x31d9, 0x0173: 0x34ef, 0x0174: 0x31fc, 0x0175: 0x3512,
+ 0x0176: 0x3224, 0x0177: 0x353f, 0x0178: 0x3238, 0x0179: 0x3247, 0x017a: 0x3567, 0x017b: 0x3251,
+ 0x017c: 0x3571, 0x017d: 0x3256, 0x017e: 0x3576, 0x017f: 0x00a7,
+ // Block 0x6, offset 0x180
+ 0x0184: 0x2e7f, 0x0185: 0x2e85,
+ 0x0186: 0x2e8b, 0x0187: 0x1ab4, 0x0188: 0x1ab7, 0x0189: 0x1b4a, 0x018a: 0x1ac9, 0x018b: 0x1acc,
+ 0x018c: 0x1b80, 0x018d: 0x2f72, 0x018e: 0x327e, 0x018f: 0x3080, 0x0190: 0x338c, 0x0191: 0x312a,
+ 0x0192: 0x343b, 0x0193: 0x31c0, 0x0194: 0x34d6, 0x0195: 0x39b9, 0x0196: 0x3b48, 0x0197: 0x39b2,
+ 0x0198: 0x3b41, 0x0199: 0x39c0, 0x019a: 0x3b4f, 0x019b: 0x39ab, 0x019c: 0x3b3a,
+ 0x019e: 0x389a, 0x019f: 0x3a29, 0x01a0: 0x3893, 0x01a1: 0x3a22, 0x01a2: 0x359d, 0x01a3: 0x35af,
+ 0x01a6: 0x302b, 0x01a7: 0x3337, 0x01a8: 0x30a8, 0x01a9: 0x33b9,
+ 0x01aa: 0x46d2, 0x01ab: 0x4763, 0x01ac: 0x397a, 0x01ad: 0x3b09, 0x01ae: 0x35c1, 0x01af: 0x35c7,
+ 0x01b0: 0x33af, 0x01b1: 0x1a84, 0x01b2: 0x1a87, 0x01b3: 0x1b11, 0x01b4: 0x3012, 0x01b5: 0x331e,
+ 0x01b8: 0x30e4, 0x01b9: 0x33f5, 0x01ba: 0x38a1, 0x01bb: 0x3a30,
+ 0x01bc: 0x3597, 0x01bd: 0x35a9, 0x01be: 0x35a3, 0x01bf: 0x35b5,
+ // Block 0x7, offset 0x1c0
+ 0x01c0: 0x2f77, 0x01c1: 0x3283, 0x01c2: 0x2f7c, 0x01c3: 0x3288, 0x01c4: 0x2ff4, 0x01c5: 0x3300,
+ 0x01c6: 0x2ff9, 0x01c7: 0x3305, 0x01c8: 0x3085, 0x01c9: 0x3391, 0x01ca: 0x308a, 0x01cb: 0x3396,
+ 0x01cc: 0x312f, 0x01cd: 0x3440, 0x01ce: 0x3134, 0x01cf: 0x3445, 0x01d0: 0x3152, 0x01d1: 0x3463,
+ 0x01d2: 0x3157, 0x01d3: 0x3468, 0x01d4: 0x31c5, 0x01d5: 0x34db, 0x01d6: 0x31ca, 0x01d7: 0x34e0,
+ 0x01d8: 0x3170, 0x01d9: 0x3481, 0x01da: 0x3189, 0x01db: 0x349f,
+ 0x01de: 0x3044, 0x01df: 0x3350,
+ 0x01e6: 0x4678, 0x01e7: 0x4709, 0x01e8: 0x46a0, 0x01e9: 0x4731,
+ 0x01ea: 0x3949, 0x01eb: 0x3ad8, 0x01ec: 0x3926, 0x01ed: 0x3ab5, 0x01ee: 0x46be, 0x01ef: 0x474f,
+ 0x01f0: 0x3942, 0x01f1: 0x3ad1, 0x01f2: 0x322e, 0x01f3: 0x3549,
+ // Block 0x8, offset 0x200
+ 0x0200: 0x86e6, 0x0201: 0x86e6, 0x0202: 0x86e6, 0x0203: 0x86e6, 0x0204: 0x86e6, 0x0205: 0x80e6,
+ 0x0206: 0x86e6, 0x0207: 0x86e6, 0x0208: 0x86e6, 0x0209: 0x86e6, 0x020a: 0x86e6, 0x020b: 0x86e6,
+ 0x020c: 0x86e6, 0x020d: 0x80e6, 0x020e: 0x80e6, 0x020f: 0x86e6, 0x0210: 0x80e6, 0x0211: 0x86e6,
+ 0x0212: 0x80e6, 0x0213: 0x86e6, 0x0214: 0x86e6, 0x0215: 0x80e8, 0x0216: 0x80dc, 0x0217: 0x80dc,
+ 0x0218: 0x80dc, 0x0219: 0x80dc, 0x021a: 0x80e8, 0x021b: 0x86d8, 0x021c: 0x80dc, 0x021d: 0x80dc,
+ 0x021e: 0x80dc, 0x021f: 0x80dc, 0x0220: 0x80dc, 0x0221: 0x80ca, 0x0222: 0x80ca, 0x0223: 0x86dc,
+ 0x0224: 0x86dc, 0x0225: 0x86dc, 0x0226: 0x86dc, 0x0227: 0x86ca, 0x0228: 0x86ca, 0x0229: 0x80dc,
+ 0x022a: 0x80dc, 0x022b: 0x80dc, 0x022c: 0x80dc, 0x022d: 0x86dc, 0x022e: 0x86dc, 0x022f: 0x80dc,
+ 0x0230: 0x86dc, 0x0231: 0x86dc, 0x0232: 0x80dc, 0x0233: 0x80dc, 0x0234: 0x8001, 0x0235: 0x8001,
+ 0x0236: 0x8001, 0x0237: 0x8001, 0x0238: 0x8601, 0x0239: 0x80dc, 0x023a: 0x80dc, 0x023b: 0x80dc,
+ 0x023c: 0x80dc, 0x023d: 0x80e6, 0x023e: 0x80e6, 0x023f: 0x80e6,
+ // Block 0x9, offset 0x240
+ 0x0240: 0x4994, 0x0241: 0x4999, 0x0242: 0x86e6, 0x0243: 0x499e, 0x0244: 0x49a3, 0x0245: 0x86f0,
+ 0x0246: 0x80e6, 0x0247: 0x80dc, 0x0248: 0x80dc, 0x0249: 0x80dc, 0x024a: 0x80e6, 0x024b: 0x80e6,
+ 0x024c: 0x80e6, 0x024d: 0x80dc, 0x024e: 0x80dc, 0x0250: 0x80e6, 0x0251: 0x80e6,
+ 0x0252: 0x80e6, 0x0253: 0x80dc, 0x0254: 0x80dc, 0x0255: 0x80dc, 0x0256: 0x80dc, 0x0257: 0x80e6,
+ 0x0258: 0x80e8, 0x0259: 0x80dc, 0x025a: 0x80dc, 0x025b: 0x80e6, 0x025c: 0x80e9, 0x025d: 0x80ea,
+ 0x025e: 0x80ea, 0x025f: 0x80e9, 0x0260: 0x80ea, 0x0261: 0x80ea, 0x0262: 0x80e9, 0x0263: 0x80e6,
+ 0x0264: 0x80e6, 0x0265: 0x80e6, 0x0266: 0x80e6, 0x0267: 0x80e6, 0x0268: 0x80e6, 0x0269: 0x80e6,
+ 0x026a: 0x80e6, 0x026b: 0x80e6, 0x026c: 0x80e6, 0x026d: 0x80e6, 0x026e: 0x80e6, 0x026f: 0x80e6,
+ 0x0274: 0x0170,
+ 0x027a: 0x428b,
+ 0x027e: 0x0037,
+ // Block 0xa, offset 0x280
+ 0x0284: 0x4240, 0x0285: 0x4461,
+ 0x0286: 0x35d3, 0x0287: 0x00d1, 0x0288: 0x35f1, 0x0289: 0x35fd, 0x028a: 0x360f,
+ 0x028c: 0x362d, 0x028e: 0x363f, 0x028f: 0x365d, 0x0290: 0x3df2, 0x0291: 0x8800,
+ 0x0295: 0x8800, 0x0297: 0x8800,
+ 0x0299: 0x8800,
+ 0x029f: 0x8800, 0x02a1: 0x8800,
+ 0x02a5: 0x8800, 0x02a9: 0x8800,
+ 0x02aa: 0x3621, 0x02ab: 0x3651, 0x02ac: 0x47e4, 0x02ad: 0x3681, 0x02ae: 0x480e, 0x02af: 0x3693,
+ 0x02b0: 0x3e5a, 0x02b1: 0x8800, 0x02b5: 0x8800,
+ 0x02b7: 0x8800, 0x02b9: 0x8800,
+ 0x02bf: 0x8800,
+ // Block 0xb, offset 0x2c0
+ 0x02c1: 0x8800, 0x02c5: 0x8800,
+ 0x02c9: 0x8800, 0x02ca: 0x4826, 0x02cb: 0x4844,
+ 0x02cc: 0x36b1, 0x02cd: 0x36c9, 0x02ce: 0x485c, 0x02d0: 0x01be, 0x02d1: 0x01d0,
+ 0x02d2: 0x01ac, 0x02d3: 0x42f2, 0x02d4: 0x42f8, 0x02d5: 0x01fa, 0x02d6: 0x01e8,
+ 0x02f0: 0x01d6, 0x02f1: 0x01eb, 0x02f2: 0x01ee, 0x02f4: 0x0188, 0x02f5: 0x01c7,
+ 0x02f9: 0x01a6,
+ // Block 0xc, offset 0x300
+ 0x0300: 0x370b, 0x0301: 0x3717, 0x0303: 0x3705,
+ 0x0306: 0x8800, 0x0307: 0x36f3,
+ 0x030c: 0x3747, 0x030d: 0x372f, 0x030e: 0x3759, 0x0310: 0x8800,
+ 0x0313: 0x8800, 0x0315: 0x8800, 0x0316: 0x8800, 0x0317: 0x8800,
+ 0x0318: 0x8800, 0x0319: 0x373b, 0x031a: 0x8800,
+ 0x031e: 0x8800, 0x0323: 0x8800,
+ 0x0327: 0x8800,
+ 0x032b: 0x8800, 0x032d: 0x8800,
+ 0x0330: 0x8800, 0x0333: 0x8800, 0x0335: 0x8800,
+ 0x0336: 0x8800, 0x0337: 0x8800, 0x0338: 0x8800, 0x0339: 0x37bf, 0x033a: 0x8800,
+ 0x033e: 0x8800,
+ // Block 0xd, offset 0x340
+ 0x0341: 0x371d, 0x0342: 0x37a1,
+ 0x0350: 0x36f9, 0x0351: 0x377d,
+ 0x0352: 0x36ff, 0x0353: 0x3783, 0x0356: 0x3711, 0x0357: 0x3795,
+ 0x0358: 0x8800, 0x0359: 0x8800, 0x035a: 0x3813, 0x035b: 0x3819, 0x035c: 0x3723, 0x035d: 0x37a7,
+ 0x035e: 0x3729, 0x035f: 0x37ad, 0x0362: 0x3735, 0x0363: 0x37b9,
+ 0x0364: 0x3741, 0x0365: 0x37c5, 0x0366: 0x374d, 0x0367: 0x37d1, 0x0368: 0x8800, 0x0369: 0x8800,
+ 0x036a: 0x381f, 0x036b: 0x3825, 0x036c: 0x3777, 0x036d: 0x37fb, 0x036e: 0x3753, 0x036f: 0x37d7,
+ 0x0370: 0x375f, 0x0371: 0x37e3, 0x0372: 0x3765, 0x0373: 0x37e9, 0x0374: 0x376b, 0x0375: 0x37ef,
+ 0x0378: 0x3771, 0x0379: 0x37f5,
+ // Block 0xe, offset 0x380
+ 0x0387: 0x1ea3,
+ 0x0391: 0x80dc,
+ 0x0392: 0x80e6, 0x0393: 0x80e6, 0x0394: 0x80e6, 0x0395: 0x80e6, 0x0396: 0x80dc, 0x0397: 0x80e6,
+ 0x0398: 0x80e6, 0x0399: 0x80e6, 0x039a: 0x80de, 0x039b: 0x80dc, 0x039c: 0x80e6, 0x039d: 0x80e6,
+ 0x039e: 0x80e6, 0x039f: 0x80e6, 0x03a0: 0x80e6, 0x03a1: 0x80e6, 0x03a2: 0x80dc, 0x03a3: 0x80dc,
+ 0x03a4: 0x80dc, 0x03a5: 0x80dc, 0x03a6: 0x80dc, 0x03a7: 0x80dc, 0x03a8: 0x80e6, 0x03a9: 0x80e6,
+ 0x03aa: 0x80dc, 0x03ab: 0x80e6, 0x03ac: 0x80e6, 0x03ad: 0x80de, 0x03ae: 0x80e4, 0x03af: 0x80e6,
+ 0x03b0: 0x800a, 0x03b1: 0x800b, 0x03b2: 0x800c, 0x03b3: 0x800d, 0x03b4: 0x800e, 0x03b5: 0x800f,
+ 0x03b6: 0x8010, 0x03b7: 0x8011, 0x03b8: 0x8012, 0x03b9: 0x8013, 0x03ba: 0x8013, 0x03bb: 0x8014,
+ 0x03bc: 0x8015, 0x03bd: 0x8016, 0x03bf: 0x8017,
+ // Block 0xf, offset 0x3c0
+ 0x03c8: 0x8800, 0x03ca: 0x8800, 0x03cb: 0x801b,
+ 0x03cc: 0x801c, 0x03cd: 0x801d, 0x03ce: 0x801e, 0x03cf: 0x801f, 0x03d0: 0x8020, 0x03d1: 0x8021,
+ 0x03d2: 0x8022, 0x03d3: 0x86e6, 0x03d4: 0x86e6, 0x03d5: 0x86dc, 0x03d6: 0x80dc, 0x03d7: 0x80e6,
+ 0x03d8: 0x80e6, 0x03d9: 0x80e6, 0x03da: 0x80e6, 0x03db: 0x80e6, 0x03dc: 0x80dc, 0x03dd: 0x80e6,
+ 0x03de: 0x80e6, 0x03df: 0x80dc,
+ 0x03f0: 0x8023, 0x03f5: 0x1ec6,
+ 0x03f6: 0x2155, 0x03f7: 0x2191, 0x03f8: 0x218c,
+ // Block 0x10, offset 0x400
+ 0x0405: 0x8800,
+ 0x0406: 0x1946, 0x0407: 0x8800, 0x0408: 0x194d, 0x0409: 0x8800, 0x040a: 0x1954, 0x040b: 0x8800,
+ 0x040c: 0x195b, 0x040d: 0x8800, 0x040e: 0x1962, 0x0411: 0x8800,
+ 0x0412: 0x1969,
+ 0x0434: 0x8007, 0x0435: 0x8600,
+ 0x043a: 0x8800, 0x043b: 0x1970,
+ 0x043c: 0x8800, 0x043d: 0x1977, 0x043e: 0x8800, 0x043f: 0x8800,
+ // Block 0x11, offset 0x440
+ 0x0440: 0x0069, 0x0441: 0x006b, 0x0442: 0x006f, 0x0443: 0x0083, 0x0444: 0x00f8, 0x0445: 0x00fb,
+ 0x0446: 0x0485, 0x0447: 0x0085, 0x0448: 0x0089, 0x0449: 0x008b, 0x044a: 0x0107, 0x044b: 0x010a,
+ 0x044c: 0x010d, 0x044d: 0x008f, 0x044f: 0x0097, 0x0450: 0x009b, 0x0451: 0x00e3,
+ 0x0452: 0x009f, 0x0453: 0x0101, 0x0454: 0x0489, 0x0455: 0x048d, 0x0456: 0x00a1, 0x0457: 0x00a9,
+ 0x0458: 0x00ab, 0x0459: 0x0495, 0x045a: 0x012b, 0x045b: 0x00ad, 0x045c: 0x0499, 0x045d: 0x01be,
+ 0x045e: 0x01c1, 0x045f: 0x01c4, 0x0460: 0x01fa, 0x0461: 0x01fd, 0x0462: 0x0093, 0x0463: 0x00a5,
+ 0x0464: 0x00ab, 0x0465: 0x00ad, 0x0466: 0x01be, 0x0467: 0x01c1, 0x0468: 0x01eb, 0x0469: 0x01fa,
+ 0x046a: 0x01fd,
+ 0x0478: 0x020c,
+ // Block 0x12, offset 0x480
+ 0x049b: 0x00fe, 0x049c: 0x0087, 0x049d: 0x0104,
+ 0x049e: 0x00d7, 0x049f: 0x010d, 0x04a0: 0x008d, 0x04a1: 0x0110, 0x04a2: 0x0113, 0x04a3: 0x0119,
+ 0x04a4: 0x011f, 0x04a5: 0x0122, 0x04a6: 0x0125, 0x04a7: 0x049d, 0x04a8: 0x016a, 0x04a9: 0x0128,
+ 0x04aa: 0x04a1, 0x04ab: 0x016d, 0x04ac: 0x0131, 0x04ad: 0x012e, 0x04ae: 0x0134, 0x04af: 0x0137,
+ 0x04b0: 0x013a, 0x04b1: 0x013d, 0x04b2: 0x0140, 0x04b3: 0x014c, 0x04b4: 0x014f, 0x04b5: 0x00ef,
+ 0x04b6: 0x0152, 0x04b7: 0x0155, 0x04b8: 0x0491, 0x04b9: 0x0158, 0x04ba: 0x015b, 0x04bb: 0x00b5,
+ 0x04bc: 0x015e, 0x04bd: 0x0161, 0x04be: 0x0164, 0x04bf: 0x01d0,
+ // Block 0x13, offset 0x4c0
+ 0x04c0: 0x2f81, 0x04c1: 0x328d, 0x04c2: 0x2f8b, 0x04c3: 0x3297, 0x04c4: 0x2f90, 0x04c5: 0x329c,
+ 0x04c6: 0x2f95, 0x04c7: 0x32a1, 0x04c8: 0x38b6, 0x04c9: 0x3a45, 0x04ca: 0x2fae, 0x04cb: 0x32ba,
+ 0x04cc: 0x2fb8, 0x04cd: 0x32c4, 0x04ce: 0x2fc7, 0x04cf: 0x32d3, 0x04d0: 0x2fbd, 0x04d1: 0x32c9,
+ 0x04d2: 0x2fc2, 0x04d3: 0x32ce, 0x04d4: 0x38d9, 0x04d5: 0x3a68, 0x04d6: 0x38e0, 0x04d7: 0x3a6f,
+ 0x04d8: 0x3003, 0x04d9: 0x330f, 0x04da: 0x3008, 0x04db: 0x3314, 0x04dc: 0x38ee, 0x04dd: 0x3a7d,
+ 0x04de: 0x300d, 0x04df: 0x3319, 0x04e0: 0x301c, 0x04e1: 0x3328, 0x04e2: 0x303a, 0x04e3: 0x3346,
+ 0x04e4: 0x3049, 0x04e5: 0x3355, 0x04e6: 0x303f, 0x04e7: 0x334b, 0x04e8: 0x304e, 0x04e9: 0x335a,
+ 0x04ea: 0x3053, 0x04eb: 0x335f, 0x04ec: 0x3099, 0x04ed: 0x33a5, 0x04ee: 0x38f5, 0x04ef: 0x3a84,
+ 0x04f0: 0x30a3, 0x04f1: 0x33b4, 0x04f2: 0x30ad, 0x04f3: 0x33be, 0x04f4: 0x30b7, 0x04f5: 0x33c8,
+ 0x04f6: 0x46aa, 0x04f7: 0x473b, 0x04f8: 0x38fc, 0x04f9: 0x3a8b, 0x04fa: 0x30d0, 0x04fb: 0x33e1,
+ 0x04fc: 0x30cb, 0x04fd: 0x33dc, 0x04fe: 0x30d5, 0x04ff: 0x33e6,
+ // Block 0x14, offset 0x500
+ 0x0500: 0x30da, 0x0501: 0x33eb, 0x0502: 0x30df, 0x0503: 0x33f0, 0x0504: 0x30f3, 0x0505: 0x3404,
+ 0x0506: 0x30fd, 0x0507: 0x340e, 0x0508: 0x310c, 0x0509: 0x341d, 0x050a: 0x3107, 0x050b: 0x3418,
+ 0x050c: 0x391f, 0x050d: 0x3aae, 0x050e: 0x392d, 0x050f: 0x3abc, 0x0510: 0x3934, 0x0511: 0x3ac3,
+ 0x0512: 0x393b, 0x0513: 0x3aca, 0x0514: 0x3139, 0x0515: 0x344a, 0x0516: 0x313e, 0x0517: 0x344f,
+ 0x0518: 0x3148, 0x0519: 0x3459, 0x051a: 0x46d7, 0x051b: 0x4768, 0x051c: 0x3981, 0x051d: 0x3b10,
+ 0x051e: 0x3161, 0x051f: 0x3472, 0x0520: 0x316b, 0x0521: 0x347c, 0x0522: 0x46e6, 0x0523: 0x4777,
+ 0x0524: 0x3988, 0x0525: 0x3b17, 0x0526: 0x398f, 0x0527: 0x3b1e, 0x0528: 0x3996, 0x0529: 0x3b25,
+ 0x052a: 0x317a, 0x052b: 0x348b, 0x052c: 0x3184, 0x052d: 0x349a, 0x052e: 0x3198, 0x052f: 0x34ae,
+ 0x0530: 0x3193, 0x0531: 0x34a9, 0x0532: 0x31d4, 0x0533: 0x34ea, 0x0534: 0x31e3, 0x0535: 0x34f9,
+ 0x0536: 0x31de, 0x0537: 0x34f4, 0x0538: 0x399d, 0x0539: 0x3b2c, 0x053a: 0x39a4, 0x053b: 0x3b33,
+ 0x053c: 0x31e8, 0x053d: 0x34fe, 0x053e: 0x31ed, 0x053f: 0x3503,
+ // Block 0x15, offset 0x540
+ 0x0540: 0x31f2, 0x0541: 0x3508, 0x0542: 0x31f7, 0x0543: 0x350d, 0x0544: 0x3206, 0x0545: 0x351c,
+ 0x0546: 0x3201, 0x0547: 0x3517, 0x0548: 0x320b, 0x0549: 0x3526, 0x054a: 0x3210, 0x054b: 0x352b,
+ 0x054c: 0x3215, 0x054d: 0x3530, 0x054e: 0x3233, 0x054f: 0x354e, 0x0550: 0x324c, 0x0551: 0x356c,
+ 0x0552: 0x325b, 0x0553: 0x357b, 0x0554: 0x3260, 0x0555: 0x3580, 0x0556: 0x3364, 0x0557: 0x3490,
+ 0x0558: 0x3521, 0x0559: 0x355d, 0x055a: 0x1d22, 0x055b: 0x42bd,
+ 0x0560: 0x4687, 0x0561: 0x4718, 0x0562: 0x2f6d, 0x0563: 0x3279,
+ 0x0564: 0x3862, 0x0565: 0x39f1, 0x0566: 0x385b, 0x0567: 0x39ea, 0x0568: 0x3870, 0x0569: 0x39ff,
+ 0x056a: 0x3869, 0x056b: 0x39f8, 0x056c: 0x38a8, 0x056d: 0x3a37, 0x056e: 0x387e, 0x056f: 0x3a0d,
+ 0x0570: 0x3877, 0x0571: 0x3a06, 0x0572: 0x388c, 0x0573: 0x3a1b, 0x0574: 0x3885, 0x0575: 0x3a14,
+ 0x0576: 0x38af, 0x0577: 0x3a3e, 0x0578: 0x469b, 0x0579: 0x472c, 0x057a: 0x2fea, 0x057b: 0x32f6,
+ 0x057c: 0x2fd6, 0x057d: 0x32e2, 0x057e: 0x38c4, 0x057f: 0x3a53,
+ // Block 0x16, offset 0x580
+ 0x0580: 0x38bd, 0x0581: 0x3a4c, 0x0582: 0x38d2, 0x0583: 0x3a61, 0x0584: 0x38cb, 0x0585: 0x3a5a,
+ 0x0586: 0x38e7, 0x0587: 0x3a76, 0x0588: 0x307b, 0x0589: 0x3387, 0x058a: 0x308f, 0x058b: 0x339b,
+ 0x058c: 0x46cd, 0x058d: 0x475e, 0x058e: 0x3120, 0x058f: 0x3431, 0x0590: 0x390a, 0x0591: 0x3a99,
+ 0x0592: 0x3903, 0x0593: 0x3a92, 0x0594: 0x3918, 0x0595: 0x3aa7, 0x0596: 0x3911, 0x0597: 0x3aa0,
+ 0x0598: 0x3973, 0x0599: 0x3b02, 0x059a: 0x3957, 0x059b: 0x3ae6, 0x059c: 0x3950, 0x059d: 0x3adf,
+ 0x059e: 0x3965, 0x059f: 0x3af4, 0x05a0: 0x395e, 0x05a1: 0x3aed, 0x05a2: 0x396c, 0x05a3: 0x3afb,
+ 0x05a4: 0x31cf, 0x05a5: 0x34e5, 0x05a6: 0x31b1, 0x05a7: 0x34c7, 0x05a8: 0x39ce, 0x05a9: 0x3b5d,
+ 0x05aa: 0x39c7, 0x05ab: 0x3b56, 0x05ac: 0x39dc, 0x05ad: 0x3b6b, 0x05ae: 0x39d5, 0x05af: 0x3b64,
+ 0x05b0: 0x39e3, 0x05b1: 0x3b72, 0x05b2: 0x321a, 0x05b3: 0x3535, 0x05b4: 0x3242, 0x05b5: 0x3562,
+ 0x05b6: 0x323d, 0x05b7: 0x3558, 0x05b8: 0x3229, 0x05b9: 0x3544,
+ // Block 0x17, offset 0x5c0
+ 0x05c0: 0x47ea, 0x05c1: 0x47f0, 0x05c2: 0x4904, 0x05c3: 0x491c, 0x05c4: 0x490c, 0x05c5: 0x4924,
+ 0x05c6: 0x4914, 0x05c7: 0x492c, 0x05c8: 0x4790, 0x05c9: 0x4796, 0x05ca: 0x4874, 0x05cb: 0x488c,
+ 0x05cc: 0x487c, 0x05cd: 0x4894, 0x05ce: 0x4884, 0x05cf: 0x489c, 0x05d0: 0x47fc, 0x05d1: 0x4802,
+ 0x05d2: 0x3da2, 0x05d3: 0x3db2, 0x05d4: 0x3daa, 0x05d5: 0x3dba,
+ 0x05d8: 0x479c, 0x05d9: 0x47a2, 0x05da: 0x3cd2, 0x05db: 0x3ce2, 0x05dc: 0x3cda, 0x05dd: 0x3cea,
+ 0x05e0: 0x4814, 0x05e1: 0x481a, 0x05e2: 0x4934, 0x05e3: 0x494c,
+ 0x05e4: 0x493c, 0x05e5: 0x4954, 0x05e6: 0x4944, 0x05e7: 0x495c, 0x05e8: 0x47a8, 0x05e9: 0x47ae,
+ 0x05ea: 0x48a4, 0x05eb: 0x48bc, 0x05ec: 0x48ac, 0x05ed: 0x48c4, 0x05ee: 0x48b4, 0x05ef: 0x48cc,
+ 0x05f0: 0x482c, 0x05f1: 0x4832, 0x05f2: 0x3e02, 0x05f3: 0x3e1a, 0x05f4: 0x3e0a, 0x05f5: 0x3e22,
+ 0x05f6: 0x3e12, 0x05f7: 0x3e2a, 0x05f8: 0x47b4, 0x05f9: 0x47ba, 0x05fa: 0x3d02, 0x05fb: 0x3d1a,
+ 0x05fc: 0x3d0a, 0x05fd: 0x3d22, 0x05fe: 0x3d12, 0x05ff: 0x3d2a,
+ // Block 0x18, offset 0x600
+ 0x0600: 0x4838, 0x0601: 0x483e, 0x0602: 0x3e32, 0x0603: 0x3e42, 0x0604: 0x3e3a, 0x0605: 0x3e4a,
+ 0x0608: 0x47c0, 0x0609: 0x47c6, 0x060a: 0x3d32, 0x060b: 0x3d42,
+ 0x060c: 0x3d3a, 0x060d: 0x3d4a, 0x0610: 0x484a, 0x0611: 0x4850,
+ 0x0612: 0x3e6a, 0x0613: 0x3e82, 0x0614: 0x3e72, 0x0615: 0x3e8a, 0x0616: 0x3e7a, 0x0617: 0x3e92,
+ 0x0619: 0x47cc, 0x061b: 0x3d52, 0x061d: 0x3d5a,
+ 0x061f: 0x3d62, 0x0620: 0x4862, 0x0621: 0x4868, 0x0622: 0x4964, 0x0623: 0x497c,
+ 0x0624: 0x496c, 0x0625: 0x4984, 0x0626: 0x4974, 0x0627: 0x498c, 0x0628: 0x47d2, 0x0629: 0x47d8,
+ 0x062a: 0x48d4, 0x062b: 0x48ec, 0x062c: 0x48dc, 0x062d: 0x48f4, 0x062e: 0x48e4, 0x062f: 0x48fc,
+ 0x0630: 0x47de, 0x0631: 0x4304, 0x0632: 0x367b, 0x0633: 0x430a, 0x0634: 0x4808, 0x0635: 0x4310,
+ 0x0636: 0x368d, 0x0637: 0x4316, 0x0638: 0x36ab, 0x0639: 0x431c, 0x063a: 0x36c3, 0x063b: 0x4322,
+ 0x063c: 0x4856, 0x063d: 0x4328,
+ // Block 0x19, offset 0x640
+ 0x0640: 0x3d8a, 0x0641: 0x3d92, 0x0642: 0x416e, 0x0643: 0x418c, 0x0644: 0x4178, 0x0645: 0x4196,
+ 0x0646: 0x4182, 0x0647: 0x41a0, 0x0648: 0x3cc2, 0x0649: 0x3cca, 0x064a: 0x40ba, 0x064b: 0x40d8,
+ 0x064c: 0x40c4, 0x064d: 0x40e2, 0x064e: 0x40ce, 0x064f: 0x40ec, 0x0650: 0x3dd2, 0x0651: 0x3dda,
+ 0x0652: 0x41aa, 0x0653: 0x41c8, 0x0654: 0x41b4, 0x0655: 0x41d2, 0x0656: 0x41be, 0x0657: 0x41dc,
+ 0x0658: 0x3cf2, 0x0659: 0x3cfa, 0x065a: 0x40f6, 0x065b: 0x4114, 0x065c: 0x4100, 0x065d: 0x411e,
+ 0x065e: 0x410a, 0x065f: 0x4128, 0x0660: 0x3eaa, 0x0661: 0x3eb2, 0x0662: 0x41e6, 0x0663: 0x4204,
+ 0x0664: 0x41f0, 0x0665: 0x420e, 0x0666: 0x41fa, 0x0667: 0x4218, 0x0668: 0x3d6a, 0x0669: 0x3d72,
+ 0x066a: 0x4132, 0x066b: 0x4150, 0x066c: 0x413c, 0x066d: 0x415a, 0x066e: 0x4146, 0x066f: 0x4164,
+ 0x0670: 0x366f, 0x0671: 0x3669, 0x0672: 0x3d7a, 0x0673: 0x3675, 0x0674: 0x3d82,
+ 0x0676: 0x47f6, 0x0677: 0x3d9a, 0x0678: 0x35df, 0x0679: 0x35d9, 0x067a: 0x35cd, 0x067b: 0x42d4,
+ 0x067c: 0x35e5, 0x067d: 0x426d, 0x067e: 0x01d3, 0x067f: 0x426d,
+ // Block 0x1a, offset 0x680
+ 0x0680: 0x4286, 0x0681: 0x4468, 0x0682: 0x3dc2, 0x0683: 0x3687, 0x0684: 0x3dca,
+ 0x0686: 0x4820, 0x0687: 0x3de2, 0x0688: 0x35eb, 0x0689: 0x42da, 0x068a: 0x35f7, 0x068b: 0x42e0,
+ 0x068c: 0x3603, 0x068d: 0x446f, 0x068e: 0x4476, 0x068f: 0x447d, 0x0690: 0x369f, 0x0691: 0x3699,
+ 0x0692: 0x3dea, 0x0693: 0x44ca, 0x0696: 0x36a5, 0x0697: 0x3dfa,
+ 0x0698: 0x361b, 0x0699: 0x3615, 0x069a: 0x3609, 0x069b: 0x42e6, 0x069d: 0x4484,
+ 0x069e: 0x448b, 0x069f: 0x4492, 0x06a0: 0x36d5, 0x06a1: 0x36cf, 0x06a2: 0x3e52, 0x06a3: 0x44d2,
+ 0x06a4: 0x36b7, 0x06a5: 0x36bd, 0x06a6: 0x36db, 0x06a7: 0x3e62, 0x06a8: 0x364b, 0x06a9: 0x3645,
+ 0x06aa: 0x3639, 0x06ab: 0x42f2, 0x06ac: 0x3633, 0x06ad: 0x445a, 0x06ae: 0x4461, 0x06af: 0x0081,
+ 0x06b2: 0x3e9a, 0x06b3: 0x36e1, 0x06b4: 0x3ea2,
+ 0x06b6: 0x486e, 0x06b7: 0x3eba, 0x06b8: 0x3627, 0x06b9: 0x42ec, 0x06ba: 0x3657, 0x06bb: 0x42fe,
+ 0x06bc: 0x3663, 0x06bd: 0x4240, 0x06be: 0x4272,
+ // Block 0x1b, offset 0x6c0
+ 0x06c0: 0x1d1a, 0x06c1: 0x1d1e, 0x06c2: 0x0047, 0x06c3: 0x1d96, 0x06c5: 0x1d2a,
+ 0x06c6: 0x1d2e, 0x06c7: 0x00ec, 0x06c9: 0x1d9a, 0x06ca: 0x008f, 0x06cb: 0x0051,
+ 0x06cc: 0x0051, 0x06cd: 0x0051, 0x06ce: 0x0091, 0x06cf: 0x00dd, 0x06d0: 0x0053, 0x06d1: 0x0053,
+ 0x06d2: 0x0059, 0x06d3: 0x0099, 0x06d5: 0x005d, 0x06d6: 0x1acf,
+ 0x06d9: 0x0061, 0x06da: 0x0063, 0x06db: 0x0065, 0x06dc: 0x0065, 0x06dd: 0x0065,
+ 0x06e0: 0x1ae1, 0x06e1: 0x1d0a, 0x06e2: 0x1aea,
+ 0x06e4: 0x0075, 0x06e6: 0x01b8, 0x06e8: 0x0075,
+ 0x06ea: 0x0057, 0x06eb: 0x42b8, 0x06ec: 0x0045, 0x06ed: 0x0047, 0x06ef: 0x008b,
+ 0x06f0: 0x004b, 0x06f1: 0x004d, 0x06f3: 0x005b, 0x06f4: 0x009f, 0x06f5: 0x020f,
+ 0x06f6: 0x0212, 0x06f7: 0x0215, 0x06f8: 0x0218, 0x06f9: 0x0093, 0x06fb: 0x1cda,
+ 0x06fc: 0x01e8, 0x06fd: 0x01c1, 0x06fe: 0x0179, 0x06ff: 0x01a0,
+ // Block 0x1c, offset 0x700
+ 0x0700: 0x04d5, 0x0705: 0x0049,
+ 0x0706: 0x0089, 0x0707: 0x008b, 0x0708: 0x0093, 0x0709: 0x0095,
+ 0x0710: 0x2370, 0x0711: 0x237c,
+ 0x0712: 0x2430, 0x0713: 0x2358, 0x0714: 0x23dc, 0x0715: 0x2364, 0x0716: 0x23e2, 0x0717: 0x23fa,
+ 0x0718: 0x2406, 0x0719: 0x236a, 0x071a: 0x240c, 0x071b: 0x2376, 0x071c: 0x2400, 0x071d: 0x2412,
+ 0x071e: 0x2418, 0x071f: 0x1dfe, 0x0720: 0x0053, 0x0721: 0x1a9c, 0x0722: 0x1ce6, 0x0723: 0x1aa5,
+ 0x0724: 0x006d, 0x0725: 0x1aed, 0x0726: 0x1d12, 0x0727: 0x1e8a, 0x0728: 0x1aa8, 0x0729: 0x0071,
+ 0x072a: 0x1af9, 0x072b: 0x1d16, 0x072c: 0x0059, 0x072d: 0x0047, 0x072e: 0x0049, 0x072f: 0x005b,
+ 0x0730: 0x0093, 0x0731: 0x1b26, 0x0732: 0x1d5a, 0x0733: 0x1b2f, 0x0734: 0x00ad, 0x0735: 0x1ba4,
+ 0x0736: 0x1d8e, 0x0737: 0x1e9e, 0x0738: 0x1b32, 0x0739: 0x00b1, 0x073a: 0x1ba7, 0x073b: 0x1d92,
+ 0x073c: 0x0099, 0x073d: 0x0087, 0x073e: 0x0089, 0x073f: 0x009b,
+ // Block 0x1d, offset 0x740
+ 0x0741: 0x3bf0, 0x0743: 0x8800, 0x0744: 0x3bf7, 0x0745: 0x8800,
+ 0x0747: 0x3bfe, 0x0748: 0x8800, 0x0749: 0x3c05,
+ 0x074d: 0x8800,
+ 0x0760: 0x2f4f, 0x0761: 0x8800, 0x0762: 0x3c13,
+ 0x0764: 0x8800, 0x0765: 0x8800,
+ 0x076d: 0x3c0c, 0x076e: 0x2f4a, 0x076f: 0x2f54,
+ 0x0770: 0x3c1a, 0x0771: 0x3c21, 0x0772: 0x8800, 0x0773: 0x8800, 0x0774: 0x3c28, 0x0775: 0x3c2f,
+ 0x0776: 0x8800, 0x0777: 0x8800, 0x0778: 0x3c36, 0x0779: 0x3c3d, 0x077a: 0x8800, 0x077b: 0x8800,
+ 0x077c: 0x8800, 0x077d: 0x8800,
+ // Block 0x1e, offset 0x780
+ 0x0780: 0x3c44, 0x0781: 0x3c4b, 0x0782: 0x8800, 0x0783: 0x8800, 0x0784: 0x3c60, 0x0785: 0x3c67,
+ 0x0786: 0x8800, 0x0787: 0x8800, 0x0788: 0x3c6e, 0x0789: 0x3c75,
+ 0x0791: 0x8800,
+ 0x0792: 0x8800,
+ 0x07a2: 0x8800,
+ 0x07a8: 0x8800, 0x07a9: 0x8800,
+ 0x07ab: 0x8800, 0x07ac: 0x3c8a, 0x07ad: 0x3c91, 0x07ae: 0x3c98, 0x07af: 0x3c9f,
+ 0x07b2: 0x8800, 0x07b3: 0x8800, 0x07b4: 0x8800, 0x07b5: 0x8800,
+ // Block 0x1f, offset 0x7c0
+ 0x07e0: 0x0023, 0x07e1: 0x0025, 0x07e2: 0x0027, 0x07e3: 0x0029,
+ 0x07e4: 0x002b, 0x07e5: 0x002d, 0x07e6: 0x002f, 0x07e7: 0x0031, 0x07e8: 0x0033, 0x07e9: 0x19c4,
+ 0x07ea: 0x19c7, 0x07eb: 0x19ca, 0x07ec: 0x19cd, 0x07ed: 0x19d0, 0x07ee: 0x19d3, 0x07ef: 0x19d6,
+ 0x07f0: 0x19d9, 0x07f1: 0x19dc, 0x07f2: 0x19df, 0x07f3: 0x19e8, 0x07f4: 0x1baa, 0x07f5: 0x1bae,
+ 0x07f6: 0x1bb2, 0x07f7: 0x1bb6, 0x07f8: 0x1bba, 0x07f9: 0x1bbe, 0x07fa: 0x1bc2, 0x07fb: 0x1bc6,
+ 0x07fc: 0x1bca, 0x07fd: 0x1dc2, 0x07fe: 0x1dc7, 0x07ff: 0x1dcc,
+ // Block 0x20, offset 0x800
+ 0x0800: 0x1dd1, 0x0801: 0x1dd6, 0x0802: 0x1ddb, 0x0803: 0x1de0, 0x0804: 0x1de5, 0x0805: 0x1dea,
+ 0x0806: 0x1def, 0x0807: 0x1df4, 0x0808: 0x19c1, 0x0809: 0x19e5, 0x080a: 0x1a09, 0x080b: 0x1a2d,
+ 0x080c: 0x1a51, 0x080d: 0x1a5a, 0x080e: 0x1a60, 0x080f: 0x1a66, 0x0810: 0x1a6c, 0x0811: 0x1ca2,
+ 0x0812: 0x1ca6, 0x0813: 0x1caa, 0x0814: 0x1cae, 0x0815: 0x1cb2, 0x0816: 0x1cb6, 0x0817: 0x1cba,
+ 0x0818: 0x1cbe, 0x0819: 0x1cc2, 0x081a: 0x1cc6, 0x081b: 0x1cca, 0x081c: 0x1c36, 0x081d: 0x1c3a,
+ 0x081e: 0x1c3e, 0x081f: 0x1c42, 0x0820: 0x1c46, 0x0821: 0x1c4a, 0x0822: 0x1c4e, 0x0823: 0x1c52,
+ 0x0824: 0x1c56, 0x0825: 0x1c5a, 0x0826: 0x1c5e, 0x0827: 0x1c62, 0x0828: 0x1c66, 0x0829: 0x1c6a,
+ 0x082a: 0x1c6e, 0x082b: 0x1c72, 0x082c: 0x1c76, 0x082d: 0x1c7a, 0x082e: 0x1c7e, 0x082f: 0x1c82,
+ 0x0830: 0x1c86, 0x0831: 0x1c8a, 0x0832: 0x1c8e, 0x0833: 0x1c92, 0x0834: 0x1c96, 0x0835: 0x1c9a,
+ 0x0836: 0x0043, 0x0837: 0x0045, 0x0838: 0x0047, 0x0839: 0x0049, 0x083a: 0x004b, 0x083b: 0x004d,
+ 0x083c: 0x004f, 0x083d: 0x0051, 0x083e: 0x0053, 0x083f: 0x0055,
+ // Block 0x21, offset 0x840
+ 0x0840: 0x0731, 0x0841: 0x0755, 0x0842: 0x0761, 0x0843: 0x0771, 0x0844: 0x0779, 0x0845: 0x0785,
+ 0x0846: 0x078d, 0x0847: 0x0795, 0x0848: 0x07a1, 0x0849: 0x07f5, 0x084a: 0x080d, 0x084b: 0x081d,
+ 0x084c: 0x082d, 0x084d: 0x083d, 0x084e: 0x084d, 0x084f: 0x086d, 0x0850: 0x0871, 0x0851: 0x0875,
+ 0x0852: 0x08a9, 0x0853: 0x08d1, 0x0854: 0x08e1, 0x0855: 0x08e9, 0x0856: 0x08ed, 0x0857: 0x08f9,
+ 0x0858: 0x0915, 0x0859: 0x0919, 0x085a: 0x0931, 0x085b: 0x0935, 0x085c: 0x093d, 0x085d: 0x094d,
+ 0x085e: 0x09e9, 0x085f: 0x09fd, 0x0860: 0x0a3d, 0x0861: 0x0a51, 0x0862: 0x0a59, 0x0863: 0x0a5d,
+ 0x0864: 0x0a6d, 0x0865: 0x0a89, 0x0866: 0x0ab5, 0x0867: 0x0ac1, 0x0868: 0x0ae1, 0x0869: 0x0aed,
+ 0x086a: 0x0af1, 0x086b: 0x0af5, 0x086c: 0x0b0d, 0x086d: 0x0b11, 0x086e: 0x0b3d, 0x086f: 0x0b49,
+ 0x0870: 0x0b51, 0x0871: 0x0b59, 0x0872: 0x0b69, 0x0873: 0x0b71, 0x0874: 0x0b79, 0x0875: 0x0ba5,
+ 0x0876: 0x0ba9, 0x0877: 0x0bb1, 0x0878: 0x0bb5, 0x0879: 0x0bbd, 0x087a: 0x0bc5, 0x087b: 0x0bd5,
+ 0x087c: 0x0bf1, 0x087d: 0x0c69, 0x087e: 0x0c7d, 0x087f: 0x0c81,
+ // Block 0x22, offset 0x880
+ 0x0880: 0x0d01, 0x0881: 0x0d05, 0x0882: 0x0d19, 0x0883: 0x0d1d, 0x0884: 0x0d25, 0x0885: 0x0d2d,
+ 0x0886: 0x0d35, 0x0887: 0x0d41, 0x0888: 0x0d69, 0x0889: 0x0d79, 0x088a: 0x0d8d, 0x088b: 0x0dfd,
+ 0x088c: 0x0e09, 0x088d: 0x0e19, 0x088e: 0x0e25, 0x088f: 0x0e31, 0x0890: 0x0e39, 0x0891: 0x0e3d,
+ 0x0892: 0x0e41, 0x0893: 0x0e45, 0x0894: 0x0e49, 0x0895: 0x0f01, 0x0896: 0x0f49, 0x0897: 0x0f55,
+ 0x0898: 0x0f59, 0x0899: 0x0f5d, 0x089a: 0x0f61, 0x089b: 0x0f69, 0x089c: 0x0f6d, 0x089d: 0x0f81,
+ 0x089e: 0x0f9d, 0x089f: 0x0fa5, 0x08a0: 0x0fe5, 0x08a1: 0x0fe9, 0x08a2: 0x0ff1, 0x08a3: 0x0ff5,
+ 0x08a4: 0x0ffd, 0x08a5: 0x1001, 0x08a6: 0x1025, 0x08a7: 0x1029, 0x08a8: 0x1045, 0x08a9: 0x1049,
+ 0x08aa: 0x104d, 0x08ab: 0x1051, 0x08ac: 0x1065, 0x08ad: 0x1089, 0x08ae: 0x108d, 0x08af: 0x1091,
+ 0x08b0: 0x10b5, 0x08b1: 0x10f5, 0x08b2: 0x10f9, 0x08b3: 0x1119, 0x08b4: 0x1129, 0x08b5: 0x1131,
+ 0x08b6: 0x1151, 0x08b7: 0x1175, 0x08b8: 0x11b9, 0x08b9: 0x11c1, 0x08ba: 0x11d5, 0x08bb: 0x11e1,
+ 0x08bc: 0x11e9, 0x08bd: 0x11f1, 0x08be: 0x11f5, 0x08bf: 0x11f9,
+ // Block 0x23, offset 0x8c0
+ 0x08c0: 0x1211, 0x08c1: 0x1215, 0x08c2: 0x1231, 0x08c3: 0x1239, 0x08c4: 0x1241, 0x08c5: 0x1245,
+ 0x08c6: 0x1251, 0x08c7: 0x1259, 0x08c8: 0x125d, 0x08c9: 0x1261, 0x08ca: 0x1269, 0x08cb: 0x126d,
+ 0x08cc: 0x130d, 0x08cd: 0x1321, 0x08ce: 0x1355, 0x08cf: 0x1359, 0x08d0: 0x1361, 0x08d1: 0x138d,
+ 0x08d2: 0x1395, 0x08d3: 0x139d, 0x08d4: 0x13a5, 0x08d5: 0x13e1, 0x08d6: 0x13e5, 0x08d7: 0x13ed,
+ 0x08d8: 0x13f1, 0x08d9: 0x13f5, 0x08da: 0x1421, 0x08db: 0x1425, 0x08dc: 0x142d, 0x08dd: 0x1441,
+ 0x08de: 0x1445, 0x08df: 0x1461, 0x08e0: 0x1469, 0x08e1: 0x146d, 0x08e2: 0x1491, 0x08e3: 0x14b1,
+ 0x08e4: 0x14c1, 0x08e5: 0x14c5, 0x08e6: 0x14cd, 0x08e7: 0x14f9, 0x08e8: 0x14fd, 0x08e9: 0x150d,
+ 0x08ea: 0x1531, 0x08eb: 0x153d, 0x08ec: 0x154d, 0x08ed: 0x1565, 0x08ee: 0x156d, 0x08ef: 0x1571,
+ 0x08f0: 0x1575, 0x08f1: 0x1579, 0x08f2: 0x1585, 0x08f3: 0x1589, 0x08f4: 0x1591, 0x08f5: 0x15ad,
+ 0x08f6: 0x15b1, 0x08f7: 0x15b5, 0x08f8: 0x15cd, 0x08f9: 0x15d1, 0x08fa: 0x15d9, 0x08fb: 0x15ed,
+ 0x08fc: 0x15f1, 0x08fd: 0x15f5, 0x08fe: 0x15fd, 0x08ff: 0x1601,
+ // Block 0x24, offset 0x900
+ 0x0906: 0x8800, 0x090b: 0x8800,
+ 0x090c: 0x3ef2, 0x090d: 0x8800, 0x090e: 0x3efa, 0x090f: 0x8800, 0x0910: 0x3f02, 0x0911: 0x8800,
+ 0x0912: 0x3f0a, 0x0913: 0x8800, 0x0914: 0x3f12, 0x0915: 0x8800, 0x0916: 0x3f1a, 0x0917: 0x8800,
+ 0x0918: 0x3f22, 0x0919: 0x8800, 0x091a: 0x3f2a, 0x091b: 0x8800, 0x091c: 0x3f32, 0x091d: 0x8800,
+ 0x091e: 0x3f3a, 0x091f: 0x8800, 0x0920: 0x3f42, 0x0921: 0x8800, 0x0922: 0x3f4a,
+ 0x0924: 0x8800, 0x0925: 0x3f52, 0x0926: 0x8800, 0x0927: 0x3f5a, 0x0928: 0x8800, 0x0929: 0x3f62,
+ 0x092f: 0x8800,
+ 0x0930: 0x3f6a, 0x0931: 0x3f72, 0x0932: 0x8800, 0x0933: 0x3f7a, 0x0934: 0x3f82, 0x0935: 0x8800,
+ 0x0936: 0x3f8a, 0x0937: 0x3f92, 0x0938: 0x8800, 0x0939: 0x3f9a, 0x093a: 0x3fa2, 0x093b: 0x8800,
+ 0x093c: 0x3faa, 0x093d: 0x3fb2,
+ // Block 0x25, offset 0x940
+ 0x0954: 0x3eea,
+ 0x0959: 0x8608, 0x095a: 0x8608, 0x095b: 0x42c2, 0x095c: 0x42c8, 0x095d: 0x8800,
+ 0x095e: 0x3fba, 0x095f: 0x285f,
+ 0x0966: 0x8800,
+ 0x096b: 0x8800, 0x096c: 0x3fca, 0x096d: 0x8800, 0x096e: 0x3fd2, 0x096f: 0x8800,
+ 0x0970: 0x3fda, 0x0971: 0x8800, 0x0972: 0x3fe2, 0x0973: 0x8800, 0x0974: 0x3fea, 0x0975: 0x8800,
+ 0x0976: 0x3ff2, 0x0977: 0x8800, 0x0978: 0x3ffa, 0x0979: 0x8800, 0x097a: 0x4002, 0x097b: 0x8800,
+ 0x097c: 0x400a, 0x097d: 0x8800, 0x097e: 0x4012, 0x097f: 0x8800,
+ // Block 0x26, offset 0x980
+ 0x0980: 0x401a, 0x0981: 0x8800, 0x0982: 0x4022, 0x0984: 0x8800, 0x0985: 0x402a,
+ 0x0986: 0x8800, 0x0987: 0x4032, 0x0988: 0x8800, 0x0989: 0x403a,
+ 0x098f: 0x8800, 0x0990: 0x4042, 0x0991: 0x404a,
+ 0x0992: 0x8800, 0x0993: 0x4052, 0x0994: 0x405a, 0x0995: 0x8800, 0x0996: 0x4062, 0x0997: 0x406a,
+ 0x0998: 0x8800, 0x0999: 0x4072, 0x099a: 0x407a, 0x099b: 0x8800, 0x099c: 0x4082, 0x099d: 0x408a,
+ 0x09af: 0x8800,
+ 0x09b0: 0x8800, 0x09b1: 0x8800, 0x09b2: 0x8800, 0x09b4: 0x3fc2,
+ 0x09b7: 0x4092, 0x09b8: 0x409a, 0x09b9: 0x40a2, 0x09ba: 0x40aa,
+ 0x09bd: 0x8800, 0x09be: 0x40b2, 0x09bf: 0x2874,
+ // Block 0x27, offset 0x9c0
+ 0x09c0: 0x03a9, 0x09c1: 0x03ad, 0x09c2: 0x047d, 0x09c3: 0x0481, 0x09c4: 0x03b1, 0x09c5: 0x03b5,
+ 0x09c6: 0x03b9, 0x09c7: 0x0415, 0x09c8: 0x0419, 0x09c9: 0x041d, 0x09ca: 0x0421, 0x09cb: 0x0425,
+ 0x09cc: 0x0429, 0x09cd: 0x042d, 0x09ce: 0x0431,
+ 0x09d2: 0x0731, 0x09d3: 0x078d, 0x09d4: 0x073d, 0x09d5: 0x09ed, 0x09d6: 0x0741, 0x09d7: 0x0759,
+ 0x09d8: 0x0745, 0x09d9: 0x1005, 0x09da: 0x0779, 0x09db: 0x074d, 0x09dc: 0x0735, 0x09dd: 0x0a71,
+ 0x09de: 0x0a01, 0x09df: 0x07a1,
+ // Block 0x28, offset 0xa00
+ 0x0a00: 0x2196, 0x0a01: 0x219c, 0x0a02: 0x21a2, 0x0a03: 0x21a8, 0x0a04: 0x21ae, 0x0a05: 0x21b4,
+ 0x0a06: 0x21ba, 0x0a07: 0x21c0, 0x0a08: 0x21c6, 0x0a09: 0x21cc, 0x0a0a: 0x21d2, 0x0a0b: 0x21d8,
+ 0x0a0c: 0x21de, 0x0a0d: 0x21e4, 0x0a0e: 0x28d1, 0x0a0f: 0x28da, 0x0a10: 0x28e3, 0x0a11: 0x28ec,
+ 0x0a12: 0x28f5, 0x0a13: 0x28fe, 0x0a14: 0x2907, 0x0a15: 0x2910, 0x0a16: 0x2919, 0x0a17: 0x292b,
+ 0x0a18: 0x2934, 0x0a19: 0x293d, 0x0a1a: 0x2946, 0x0a1b: 0x294f, 0x0a1c: 0x2922, 0x0a1d: 0x2d74,
+ 0x0a1e: 0x2ca5, 0x0a20: 0x21ea, 0x0a21: 0x2202, 0x0a22: 0x21f6, 0x0a23: 0x224a,
+ 0x0a24: 0x2208, 0x0a25: 0x2226, 0x0a26: 0x21f0, 0x0a27: 0x2220, 0x0a28: 0x21fc, 0x0a29: 0x2232,
+ 0x0a2a: 0x2262, 0x0a2b: 0x2280, 0x0a2c: 0x227a, 0x0a2d: 0x226e, 0x0a2e: 0x22bc, 0x0a2f: 0x2250,
+ 0x0a30: 0x225c, 0x0a31: 0x2274, 0x0a32: 0x2268, 0x0a33: 0x2292, 0x0a34: 0x223e, 0x0a35: 0x2286,
+ 0x0a36: 0x22b0, 0x0a37: 0x2298, 0x0a38: 0x222c, 0x0a39: 0x220e, 0x0a3a: 0x2244, 0x0a3b: 0x2256,
+ 0x0a3c: 0x228c, 0x0a3d: 0x2214, 0x0a3e: 0x22b6, 0x0a3f: 0x2238,
+ // Block 0x29, offset 0xa40
+ 0x0a40: 0x229e, 0x0a41: 0x221a, 0x0a42: 0x22a4, 0x0a43: 0x22aa, 0x0a44: 0x09a1, 0x0a45: 0x0b75,
+ 0x0a46: 0x0d19, 0x0a47: 0x1139,
+ 0x0a50: 0x1d06, 0x0a51: 0x19eb,
+ 0x0a52: 0x19ee, 0x0a53: 0x19f1, 0x0a54: 0x19f4, 0x0a55: 0x19f7, 0x0a56: 0x19fa, 0x0a57: 0x19fd,
+ 0x0a58: 0x1a00, 0x0a59: 0x1a03, 0x0a5a: 0x1a0c, 0x0a5b: 0x1a0f, 0x0a5c: 0x1a12, 0x0a5d: 0x1a15,
+ 0x0a5e: 0x1a18, 0x0a5f: 0x1a1b, 0x0a60: 0x030d, 0x0a61: 0x0315, 0x0a62: 0x0319, 0x0a63: 0x0321,
+ 0x0a64: 0x0325, 0x0a65: 0x0329, 0x0a66: 0x0331, 0x0a67: 0x0339, 0x0a68: 0x033d, 0x0a69: 0x0345,
+ 0x0a6a: 0x0349, 0x0a6b: 0x034d, 0x0a6c: 0x0351, 0x0a6d: 0x0355, 0x0a6e: 0x27d3, 0x0a6f: 0x27da,
+ 0x0a70: 0x27e1, 0x0a71: 0x27e8, 0x0a72: 0x27ef, 0x0a73: 0x27f6, 0x0a74: 0x27fd, 0x0a75: 0x2804,
+ 0x0a76: 0x2812, 0x0a77: 0x2819, 0x0a78: 0x2820, 0x0a79: 0x2827, 0x0a7a: 0x282e, 0x0a7b: 0x2835,
+ 0x0a7c: 0x2cc4, 0x0a7d: 0x2b39, 0x0a7e: 0x280b,
+ // Block 0x2a, offset 0xa80
+ 0x0a80: 0x0731, 0x0a81: 0x078d, 0x0a82: 0x073d, 0x0a83: 0x09ed, 0x0a84: 0x0791, 0x0a85: 0x0821,
+ 0x0a86: 0x0739, 0x0a87: 0x081d, 0x0a88: 0x077d, 0x0a89: 0x08f9, 0x0a8a: 0x0d79, 0x0a8b: 0x0f01,
+ 0x0a8c: 0x0e49, 0x0a8d: 0x0d8d, 0x0a8e: 0x14cd, 0x0a8f: 0x09fd, 0x0a90: 0x0d41, 0x0a91: 0x0dbd,
+ 0x0a92: 0x0d7d, 0x0a93: 0x10bd, 0x0a94: 0x096d, 0x0a95: 0x0f75, 0x0a96: 0x13f9, 0x0a97: 0x10d1,
+ 0x0a98: 0x08b5, 0x0a99: 0x1101, 0x0a9a: 0x100d, 0x0a9b: 0x0a89, 0x0a9c: 0x1481, 0x0a9d: 0x07f1,
+ 0x0a9e: 0x091d, 0x0a9f: 0x0e69, 0x0aa0: 0x1595, 0x0aa1: 0x07b5, 0x0aa2: 0x0845, 0x0aa3: 0x0e0d,
+ 0x0aa4: 0x0741, 0x0aa5: 0x0759, 0x0aa6: 0x0745, 0x0aa7: 0x0b4d, 0x0aa8: 0x0961, 0x0aa9: 0x08f1,
+ 0x0aaa: 0x0ac9, 0x0aab: 0x0abd, 0x0aac: 0x105d, 0x0aad: 0x07b1, 0x0aae: 0x140d, 0x0aaf: 0x090d,
+ 0x0ab0: 0x0a65, 0x0ab1: 0x1a1e, 0x0ab2: 0x1a21, 0x0ab3: 0x1a24, 0x0ab4: 0x1a27, 0x0ab5: 0x1a30,
+ 0x0ab6: 0x1a33, 0x0ab7: 0x1a36, 0x0ab8: 0x1a39, 0x0ab9: 0x1a3c, 0x0aba: 0x1a3f, 0x0abb: 0x1a42,
+ 0x0abc: 0x1a45, 0x0abd: 0x1a48, 0x0abe: 0x1a4b, 0x0abf: 0x1a54,
+ // Block 0x2b, offset 0xac0
+ 0x0ac0: 0x1e08, 0x0ac1: 0x1e17, 0x0ac2: 0x1e26, 0x0ac3: 0x1e35, 0x0ac4: 0x1e44, 0x0ac5: 0x1e53,
+ 0x0ac6: 0x1e62, 0x0ac7: 0x1e71, 0x0ac8: 0x1e80, 0x0ac9: 0x22ce, 0x0aca: 0x22e0, 0x0acb: 0x22f2,
+ 0x0acc: 0x1a96, 0x0acd: 0x1d46, 0x0ace: 0x1b14, 0x0acf: 0x1cea, 0x0ad0: 0x053d, 0x0ad1: 0x0545,
+ 0x0ad2: 0x054d, 0x0ad3: 0x0555, 0x0ad4: 0x055d, 0x0ad5: 0x0561, 0x0ad6: 0x0565, 0x0ad7: 0x0569,
+ 0x0ad8: 0x056d, 0x0ad9: 0x0571, 0x0ada: 0x0575, 0x0adb: 0x0579, 0x0adc: 0x057d, 0x0add: 0x0581,
+ 0x0ade: 0x0585, 0x0adf: 0x0589, 0x0ae0: 0x058d, 0x0ae1: 0x0595, 0x0ae2: 0x0599, 0x0ae3: 0x059d,
+ 0x0ae4: 0x05a1, 0x0ae5: 0x05a5, 0x0ae6: 0x05a9, 0x0ae7: 0x05ad, 0x0ae8: 0x05b1, 0x0ae9: 0x05b5,
+ 0x0aea: 0x05b9, 0x0aeb: 0x05bd, 0x0aec: 0x05c1, 0x0aed: 0x05c5, 0x0aee: 0x05c9, 0x0aef: 0x05cd,
+ 0x0af0: 0x05d1, 0x0af1: 0x05d5, 0x0af2: 0x05d9, 0x0af3: 0x05e1, 0x0af4: 0x05e9, 0x0af5: 0x05f1,
+ 0x0af6: 0x05f5, 0x0af7: 0x05f9, 0x0af8: 0x05fd, 0x0af9: 0x0601, 0x0afa: 0x0605, 0x0afb: 0x0609,
+ 0x0afc: 0x060d, 0x0afd: 0x0611, 0x0afe: 0x0615,
+ // Block 0x2c, offset 0xb00
+ 0x0b00: 0x2cd4, 0x0b01: 0x2b60, 0x0b02: 0x2ce4, 0x0b03: 0x2a2b, 0x0b04: 0x2ede, 0x0b05: 0x2a35,
+ 0x0b06: 0x2a3f, 0x0b07: 0x2f22, 0x0b08: 0x2b6d, 0x0b09: 0x2a49, 0x0b0a: 0x2a53, 0x0b0b: 0x2a5d,
+ 0x0b0c: 0x2b94, 0x0b0d: 0x2ba1, 0x0b0e: 0x2b7a, 0x0b0f: 0x2b87, 0x0b10: 0x2eb4, 0x0b11: 0x2bae,
+ 0x0b12: 0x2bbb, 0x0b13: 0x2d86, 0x0b14: 0x2866, 0x0b15: 0x2d99, 0x0b16: 0x2dac, 0x0b17: 0x2cf4,
+ 0x0b18: 0x2bc8, 0x0b19: 0x2dbf, 0x0b1a: 0x2dd2, 0x0b1b: 0x2bd5, 0x0b1c: 0x2a67, 0x0b1d: 0x2a71,
+ 0x0b1e: 0x2ec2, 0x0b1f: 0x2be2, 0x0b20: 0x2d04, 0x0b21: 0x2eef, 0x0b22: 0x2a7b, 0x0b23: 0x2a85,
+ 0x0b24: 0x2bef, 0x0b25: 0x2a8f, 0x0b26: 0x2a99, 0x0b27: 0x287b, 0x0b28: 0x2882, 0x0b29: 0x2aa3,
+ 0x0b2a: 0x2aad, 0x0b2b: 0x2de5, 0x0b2c: 0x2bfc, 0x0b2d: 0x2d14, 0x0b2e: 0x2df8, 0x0b2f: 0x2c09,
+ 0x0b30: 0x2ac1, 0x0b31: 0x2ab7, 0x0b32: 0x2f36, 0x0b33: 0x2c16, 0x0b34: 0x2e0b, 0x0b35: 0x2acb,
+ 0x0b36: 0x2d24, 0x0b37: 0x2ad5, 0x0b38: 0x2c30, 0x0b39: 0x2adf, 0x0b3a: 0x2c3d, 0x0b3b: 0x2f00,
+ 0x0b3c: 0x2c23, 0x0b3d: 0x2d34, 0x0b3e: 0x2c4a, 0x0b3f: 0x2889,
+ // Block 0x2d, offset 0xb40
+ 0x0b40: 0x2f11, 0x0b41: 0x2ae9, 0x0b42: 0x2af3, 0x0b43: 0x2c57, 0x0b44: 0x2afd, 0x0b45: 0x2b07,
+ 0x0b46: 0x2b11, 0x0b47: 0x2d44, 0x0b48: 0x2c64, 0x0b49: 0x2890, 0x0b4a: 0x2e1e, 0x0b4b: 0x2ea9,
+ 0x0b4c: 0x2d54, 0x0b4d: 0x2c71, 0x0b4e: 0x2ed0, 0x0b4f: 0x2b1b, 0x0b50: 0x2b25, 0x0b51: 0x2c7e,
+ 0x0b52: 0x2897, 0x0b53: 0x2c8b, 0x0b54: 0x2d64, 0x0b55: 0x289e, 0x0b56: 0x2e31, 0x0b57: 0x2b2f,
+ 0x0b58: 0x1df9, 0x0b59: 0x1e0d, 0x0b5a: 0x1e1c, 0x0b5b: 0x1e2b, 0x0b5c: 0x1e3a, 0x0b5d: 0x1e49,
+ 0x0b5e: 0x1e58, 0x0b5f: 0x1e67, 0x0b60: 0x1e76, 0x0b61: 0x1e85, 0x0b62: 0x22d4, 0x0b63: 0x22e6,
+ 0x0b64: 0x22f8, 0x0b65: 0x2304, 0x0b66: 0x2310, 0x0b67: 0x231c, 0x0b68: 0x2328, 0x0b69: 0x2334,
+ 0x0b6a: 0x2340, 0x0b6b: 0x234c, 0x0b6c: 0x2388, 0x0b6d: 0x2394, 0x0b6e: 0x23a0, 0x0b6f: 0x23ac,
+ 0x0b70: 0x23b8, 0x0b71: 0x1d56, 0x0b72: 0x1b08, 0x0b73: 0x1a78, 0x0b74: 0x1d26, 0x0b75: 0x1b89,
+ 0x0b76: 0x1b98, 0x0b77: 0x1b0e, 0x0b78: 0x1d3e, 0x0b79: 0x1d42, 0x0b7a: 0x1aa2, 0x0b7b: 0x28ac,
+ 0x0b7c: 0x28ba, 0x0b7d: 0x28a5, 0x0b7e: 0x28b3, 0x0b7f: 0x2c98,
+ // Block 0x2e, offset 0xb80
+ 0x0b80: 0x1b8c, 0x0b81: 0x1b74, 0x0b82: 0x1da2, 0x0b83: 0x1b5c, 0x0b84: 0x1b35, 0x0b85: 0x1aab,
+ 0x0b86: 0x1aba, 0x0b87: 0x1a8a, 0x0b88: 0x1d32, 0x0b89: 0x1e94, 0x0b8a: 0x1b8f, 0x0b8b: 0x1b77,
+ 0x0b8c: 0x1da6, 0x0b8d: 0x1db2, 0x0b8e: 0x1b68, 0x0b8f: 0x1b3e, 0x0b90: 0x1a99, 0x0b91: 0x1d5e,
+ 0x0b92: 0x1cf2, 0x0b93: 0x1cde, 0x0b94: 0x1d0e, 0x0b95: 0x1db6, 0x0b96: 0x1b6b, 0x0b97: 0x1b0b,
+ 0x0b98: 0x1b41, 0x0b99: 0x1b20, 0x0b9a: 0x1b83, 0x0b9b: 0x1dba, 0x0b9c: 0x1b6e, 0x0b9d: 0x1b02,
+ 0x0b9e: 0x1b44, 0x0b9f: 0x1d7e, 0x0ba0: 0x1d36, 0x0ba1: 0x1b56, 0x0ba2: 0x1d66, 0x0ba3: 0x1d82,
+ 0x0ba4: 0x1d3a, 0x0ba5: 0x1b59, 0x0ba6: 0x1d6a, 0x0ba7: 0x242a, 0x0ba8: 0x243e, 0x0ba9: 0x1ad8,
+ 0x0baa: 0x1d62, 0x0bab: 0x1cf6, 0x0bac: 0x1ce2, 0x0bad: 0x1d8a, 0x0bae: 0x28c1, 0x0baf: 0x2958,
+ 0x0bb0: 0x1b9b, 0x0bb1: 0x1b86, 0x0bb2: 0x1dbe, 0x0bb3: 0x1b71, 0x0bb4: 0x1b92, 0x0bb5: 0x1b7a,
+ 0x0bb6: 0x1daa, 0x0bb7: 0x1b5f, 0x0bb8: 0x1b38, 0x0bb9: 0x1ac3, 0x0bba: 0x1b95, 0x0bbb: 0x1b7d,
+ 0x0bbc: 0x1dae, 0x0bbd: 0x1b62, 0x0bbe: 0x1b3b, 0x0bbf: 0x1ac6,
+ // Block 0x2f, offset 0xbc0
+ 0x0bc0: 0x1d6e, 0x0bc1: 0x1cfa, 0x0bc2: 0x1e8f, 0x0bc3: 0x1a7b, 0x0bc4: 0x1afc, 0x0bc5: 0x1aff,
+ 0x0bc6: 0x2437, 0x0bc7: 0x1cd6, 0x0bc8: 0x1b05, 0x0bc9: 0x1a8d, 0x0bca: 0x1b23, 0x0bcb: 0x1a90,
+ 0x0bcc: 0x1b2c, 0x0bcd: 0x1aae, 0x0bce: 0x1ab1, 0x0bcf: 0x1b47, 0x0bd0: 0x1b4d, 0x0bd1: 0x1b50,
+ 0x0bd2: 0x1d72, 0x0bd3: 0x1b53, 0x0bd4: 0x1b65, 0x0bd5: 0x1d7a, 0x0bd6: 0x1d86, 0x0bd7: 0x1ad2,
+ 0x0bd8: 0x1e99, 0x0bd9: 0x1cfe, 0x0bda: 0x1ad5, 0x0bdb: 0x1b9e, 0x0bdc: 0x1ae7, 0x0bdd: 0x1af6,
+ 0x0bde: 0x2424, 0x0bdf: 0x241e, 0x0be0: 0x1e03, 0x0be1: 0x1e12, 0x0be2: 0x1e21, 0x0be3: 0x1e30,
+ 0x0be4: 0x1e3f, 0x0be5: 0x1e4e, 0x0be6: 0x1e5d, 0x0be7: 0x1e6c, 0x0be8: 0x1e7b, 0x0be9: 0x22c8,
+ 0x0bea: 0x22da, 0x0beb: 0x22ec, 0x0bec: 0x22fe, 0x0bed: 0x230a, 0x0bee: 0x2316, 0x0bef: 0x2322,
+ 0x0bf0: 0x232e, 0x0bf1: 0x233a, 0x0bf2: 0x2346, 0x0bf3: 0x2382, 0x0bf4: 0x238e, 0x0bf5: 0x239a,
+ 0x0bf6: 0x23a6, 0x0bf7: 0x23b2, 0x0bf8: 0x23be, 0x0bf9: 0x23c4, 0x0bfa: 0x23ca, 0x0bfb: 0x23d0,
+ 0x0bfc: 0x23d6, 0x0bfd: 0x23e8, 0x0bfe: 0x23ee, 0x0bff: 0x1d52,
+ // Block 0x30, offset 0xc00
+ 0x0c00: 0x13e9, 0x0c01: 0x0d6d, 0x0c02: 0x1445, 0x0c03: 0x1411, 0x0c04: 0x0ec9, 0x0c05: 0x075d,
+ 0x0c06: 0x0951, 0x0c07: 0x1699, 0x0c08: 0x1699, 0x0c09: 0x0a7d, 0x0c0a: 0x14cd, 0x0c0b: 0x09b5,
+ 0x0c0c: 0x0a79, 0x0c0d: 0x0c61, 0x0c0e: 0x1041, 0x0c0f: 0x11d1, 0x0c10: 0x1309, 0x0c11: 0x1345,
+ 0x0c12: 0x1379, 0x0c13: 0x148d, 0x0c14: 0x0de5, 0x0c15: 0x0e71, 0x0c16: 0x0f1d, 0x0c17: 0x0fb5,
+ 0x0c18: 0x12d1, 0x0c19: 0x14b5, 0x0c1a: 0x15e1, 0x0c1b: 0x0781, 0x0c1c: 0x0925, 0x0c1d: 0x0df9,
+ 0x0c1e: 0x0f41, 0x0c1f: 0x1305, 0x0c20: 0x1631, 0x0c21: 0x0b25, 0x0c22: 0x0ee9, 0x0c23: 0x12f5,
+ 0x0c24: 0x1389, 0x0c25: 0x0c95, 0x0c26: 0x122d, 0x0c27: 0x1351, 0x0c28: 0x0b91, 0x0c29: 0x0d81,
+ 0x0c2a: 0x0e89, 0x0c2b: 0x0f8d, 0x0c2c: 0x1499, 0x0c2d: 0x07c1, 0x0c2e: 0x0859, 0x0c2f: 0x08c5,
+ 0x0c30: 0x0cfd, 0x0c31: 0x0df1, 0x0c32: 0x0f3d, 0x0c33: 0x1061, 0x0c34: 0x11e9, 0x0c35: 0x12fd,
+ 0x0c36: 0x1315, 0x0c37: 0x1439, 0x0c38: 0x155d, 0x0c39: 0x1611, 0x0c3a: 0x162d, 0x0c3b: 0x109d,
+ 0x0c3c: 0x10dd, 0x0c3d: 0x1195, 0x0c3e: 0x12b5, 0x0c3f: 0x14e9,
+ // Block 0x31, offset 0xc40
+ 0x0c40: 0x1639, 0x0c41: 0x13bd, 0x0c42: 0x0a39, 0x0c43: 0x0bad, 0x0c44: 0x114d, 0x0c45: 0x120d,
+ 0x0c46: 0x0f71, 0x0c47: 0x10a5, 0x0c48: 0x1409, 0x0c49: 0x1555, 0x0c4a: 0x0a35, 0x0c4b: 0x0b01,
+ 0x0c4c: 0x0de9, 0x0c4d: 0x0e9d, 0x0c4e: 0x0ed1, 0x0c4f: 0x1185, 0x0c50: 0x11ad, 0x0c51: 0x1515,
+ 0x0c52: 0x08c1, 0x0c53: 0x1219, 0x0c54: 0x0865, 0x0c55: 0x0861, 0x0c56: 0x1109, 0x0c57: 0x1199,
+ 0x0c58: 0x12cd, 0x0c59: 0x151d, 0x0c5a: 0x13d9, 0x0c5b: 0x0c99, 0x0c5c: 0x0de5, 0x0c5d: 0x13c9,
+ 0x0c5e: 0x0769, 0x0c5f: 0x0ad5, 0x0c60: 0x0c05, 0x0c61: 0x0fa1, 0x0c62: 0x1021, 0x0c63: 0x08e5,
+ 0x0c64: 0x10ad, 0x0c65: 0x07d1, 0x0c66: 0x0be9, 0x0c67: 0x0749, 0x0c68: 0x0e5d, 0x0c69: 0x0d15,
+ 0x0c6a: 0x1181, 0x0c6b: 0x0939, 0x0c6c: 0x0a25, 0x0c6d: 0x106d, 0x0c6e: 0x12d5, 0x0c6f: 0x13ad,
+ 0x0c70: 0x0e29, 0x0c71: 0x1469, 0x0c72: 0x0e55, 0x0c73: 0x0ca9, 0x0c74: 0x128d, 0x0c75: 0x0cc9,
+ 0x0c76: 0x101d, 0x0c77: 0x079d, 0x0c78: 0x0819, 0x0c79: 0x085d, 0x0c7a: 0x0dc5, 0x0c7b: 0x116d,
+ 0x0c7c: 0x1265, 0x0c7d: 0x13b9, 0x0c7e: 0x14c9, 0x0c7f: 0x08cd,
+ // Block 0x32, offset 0xc80
+ 0x0c80: 0x0981, 0x0c81: 0x0a89, 0x0c82: 0x0ba1, 0x0c83: 0x0d31, 0x0c84: 0x0eed, 0x0c85: 0x10b1,
+ 0x0c86: 0x1505, 0x0c87: 0x15e9, 0x0c88: 0x163d, 0x0c89: 0x1655, 0x0c8a: 0x08a9, 0x0c8b: 0x0d65,
+ 0x0c8c: 0x0e15, 0x0c8d: 0x145d, 0x0c8e: 0x0b6d, 0x0c8f: 0x0c49, 0x0c90: 0x0c65, 0x0c91: 0x0cf5,
+ 0x0c92: 0x0edd, 0x0c93: 0x0f29, 0x0c94: 0x0fd9, 0x0c95: 0x10fd, 0x0c96: 0x11a1, 0x0c97: 0x1205,
+ 0x0c98: 0x144d, 0x0c99: 0x12dd, 0x0c9a: 0x1475, 0x0c9b: 0x14ed, 0x0c9c: 0x0881, 0x0c9d: 0x08ad,
+ 0x0c9e: 0x0995, 0x0c9f: 0x0f19, 0x0ca0: 0x1365, 0x0ca1: 0x13ad, 0x0ca2: 0x0b8d, 0x0ca3: 0x0bfd,
+ 0x0ca4: 0x0cc1, 0x0ca5: 0x0e21, 0x0ca6: 0x1149, 0x0ca7: 0x0f95, 0x0ca8: 0x07ad, 0x0ca9: 0x09f1,
+ 0x0caa: 0x0ad5, 0x0cab: 0x0b39, 0x0cac: 0x0c09, 0x0cad: 0x0fb1, 0x0cae: 0x0fcd, 0x0caf: 0x11dd,
+ 0x0cb0: 0x11fd, 0x0cb1: 0x14d1, 0x0cb2: 0x1551, 0x0cb3: 0x1561, 0x0cb4: 0x159d, 0x0cb5: 0x07c5,
+ 0x0cb6: 0x10f1, 0x0cb7: 0x14bd, 0x0cb8: 0x1539, 0x0cb9: 0x0c21, 0x0cba: 0x0789, 0x0cbb: 0x07e9,
+ 0x0cbc: 0x0ad9, 0x0cbd: 0x0af9, 0x0cbe: 0x0d21, 0x0cbf: 0x0de5,
+ // Block 0x33, offset 0xcc0
+ 0x0cc0: 0x0f35, 0x0cc1: 0x103d, 0x0cc2: 0x12e9, 0x0cc3: 0x1489, 0x0cc4: 0x1691, 0x0cc5: 0x0d55,
+ 0x0cc6: 0x1511, 0x0cc7: 0x08a5, 0x0cc8: 0x0da1, 0x0cc9: 0x0dad, 0x0cca: 0x0e81, 0x0ccb: 0x0eb9,
+ 0x0ccc: 0x0fbd, 0x0ccd: 0x1019, 0x0cce: 0x1099, 0x0ccf: 0x117d, 0x0cd0: 0x15a9, 0x0cd1: 0x0821,
+ 0x0cd2: 0x0c75, 0x0cd3: 0x1521, 0x0cd4: 0x07d9, 0x0cd5: 0x0b1d, 0x0cd6: 0x0ea1, 0x0cd7: 0x1451,
+ 0x0cd8: 0x0bd9, 0x0cd9: 0x0c29, 0x0cda: 0x0db5, 0x0cdb: 0x0fa1, 0x0cdc: 0x1529, 0x0cdd: 0x0889,
+ 0x0cde: 0x0971, 0x0cdf: 0x0b09, 0x0ce0: 0x0d45, 0x0ce1: 0x0d91, 0x0ce2: 0x0dd1, 0x0ce3: 0x0e65,
+ 0x0ce4: 0x0fb9, 0x0ce5: 0x102d, 0x0ce6: 0x11c9, 0x0ce7: 0x1369, 0x0ce8: 0x1375, 0x0ce9: 0x14c5,
+ 0x0cea: 0x1545, 0x0ceb: 0x08f5, 0x0cec: 0x0ebd, 0x0ced: 0x0975, 0x0cee: 0x0f39, 0x0cef: 0x0fdd,
+ 0x0cf0: 0x12f9, 0x0cf1: 0x152d, 0x0cf2: 0x1619, 0x0cf3: 0x1641, 0x0cf4: 0x0da9, 0x0cf5: 0x0e99,
+ 0x0cf6: 0x1235, 0x0cf7: 0x1129, 0x0cf8: 0x1135, 0x0cf9: 0x1159, 0x0cfa: 0x0f89, 0x0cfb: 0x0f11,
+ 0x0cfc: 0x13d5, 0x0cfd: 0x07a5, 0x0cfe: 0x129d, 0x0cff: 0x088d,
+ // Block 0x34, offset 0xd00
+ 0x0d00: 0x087d, 0x0d01: 0x0b7d, 0x0d02: 0x0c9d, 0x0d03: 0x1165, 0x0d04: 0x0ac5, 0x0d05: 0x0e75,
+ 0x0d06: 0x0d61, 0x0d07: 0x1459, 0x0d08: 0x1359, 0x0d09: 0x1519, 0x0d0a: 0x1395, 0x0d0b: 0x0b99,
+ 0x0d0c: 0x07f9, 0x0d0d: 0x09cd, 0x0d10: 0x0a21,
+ 0x0d12: 0x0d51, 0x0d15: 0x0869, 0x0d16: 0x0f91, 0x0d17: 0x1055,
+ 0x0d18: 0x10b9, 0x0d19: 0x10d5, 0x0d1a: 0x10d9, 0x0d1b: 0x10ed, 0x0d1c: 0x1569, 0x0d1d: 0x115d,
+ 0x0d1e: 0x11e1, 0x0d20: 0x1301, 0x0d22: 0x13c5,
+ 0x0d25: 0x1479, 0x0d26: 0x14a5,
+ 0x0d2a: 0x15bd, 0x0d2b: 0x15c1, 0x0d2c: 0x15c5, 0x0d2d: 0x1629, 0x0d2e: 0x149d, 0x0d2f: 0x1535,
+ 0x0d30: 0x07c9, 0x0d31: 0x07ed, 0x0d32: 0x0801, 0x0d33: 0x08bd, 0x0d34: 0x08c9, 0x0d35: 0x0909,
+ 0x0d36: 0x09bd, 0x0d37: 0x09d9, 0x0d38: 0x09e1, 0x0d39: 0x0a1d, 0x0d3a: 0x0a29, 0x0d3b: 0x0b05,
+ 0x0d3c: 0x0b0d, 0x0d3d: 0x0c15, 0x0d3e: 0x0c3d, 0x0d3f: 0x0c45,
+ // Block 0x35, offset 0xd40
+ 0x0d40: 0x0c5d, 0x0d41: 0x0d09, 0x0d42: 0x0d39, 0x0d43: 0x0d59, 0x0d44: 0x0dc9, 0x0d45: 0x0e8d,
+ 0x0d46: 0x0ea9, 0x0d47: 0x0ed9, 0x0d48: 0x0f2d, 0x0d49: 0x0f4d, 0x0d4a: 0x0fc1, 0x0d4b: 0x10a1,
+ 0x0d4c: 0x10bd, 0x0d4d: 0x10c5, 0x0d4e: 0x10c1, 0x0d4f: 0x10c9, 0x0d50: 0x10cd, 0x0d51: 0x10d1,
+ 0x0d52: 0x10e5, 0x0d53: 0x10e9, 0x0d54: 0x110d, 0x0d55: 0x1121, 0x0d56: 0x113d, 0x0d57: 0x11a1,
+ 0x0d58: 0x11a9, 0x0d59: 0x11b1, 0x0d5a: 0x11c5, 0x0d5b: 0x11ed, 0x0d5c: 0x123d, 0x0d5d: 0x1271,
+ 0x0d5e: 0x1271, 0x0d5f: 0x12d9, 0x0d60: 0x1381, 0x0d61: 0x1399, 0x0d62: 0x13cd, 0x0d63: 0x13d1,
+ 0x0d64: 0x1415, 0x0d65: 0x1419, 0x0d66: 0x1471, 0x0d67: 0x1479, 0x0d68: 0x1549, 0x0d69: 0x158d,
+ 0x0d6a: 0x15a5, 0x0d6b: 0x0c0d, 0x0d6c: 0x1780, 0x0d6d: 0x1255,
+ 0x0d70: 0x0751, 0x0d71: 0x0855, 0x0d72: 0x0815, 0x0d73: 0x07bd, 0x0d74: 0x07fd, 0x0d75: 0x0829,
+ 0x0d76: 0x08b9, 0x0d77: 0x08d5, 0x0d78: 0x09bd, 0x0d79: 0x09a9, 0x0d7a: 0x09b9, 0x0d7b: 0x09d5,
+ 0x0d7c: 0x0a21, 0x0d7d: 0x0a31, 0x0d7e: 0x0a75, 0x0d7f: 0x0a81,
+ // Block 0x36, offset 0xd80
+ 0x0d80: 0x0a9d, 0x0d81: 0x0aad, 0x0d82: 0x0b95, 0x0d83: 0x0b9d, 0x0d84: 0x0bcd, 0x0d85: 0x0bed,
+ 0x0d86: 0x0c1d, 0x0d87: 0x0c35, 0x0d88: 0x0c25, 0x0d89: 0x0c45, 0x0d8a: 0x0c39, 0x0d8b: 0x0c5d,
+ 0x0d8c: 0x0c79, 0x0d8d: 0x0cd1, 0x0d8e: 0x0cdd, 0x0d8f: 0x0ce5, 0x0d90: 0x0d0d, 0x0d91: 0x0d51,
+ 0x0d92: 0x0d81, 0x0d93: 0x0d85, 0x0d94: 0x0d99, 0x0d95: 0x0e19, 0x0d96: 0x0e29, 0x0d97: 0x0e81,
+ 0x0d98: 0x0ecd, 0x0d99: 0x0ec5, 0x0d9a: 0x0ed9, 0x0d9b: 0x0ef5, 0x0d9c: 0x0f2d, 0x0d9d: 0x1085,
+ 0x0d9e: 0x0f51, 0x0d9f: 0x0f85, 0x0da0: 0x0f91, 0x0da1: 0x0fd1, 0x0da2: 0x0fed, 0x0da3: 0x1011,
+ 0x0da4: 0x1035, 0x0da5: 0x1039, 0x0da6: 0x1055, 0x0da7: 0x1059, 0x0da8: 0x1069, 0x0da9: 0x107d,
+ 0x0daa: 0x1079, 0x0dab: 0x10a9, 0x0dac: 0x1125, 0x0dad: 0x113d, 0x0dae: 0x1155, 0x0daf: 0x118d,
+ 0x0db0: 0x11a1, 0x0db1: 0x11bd, 0x0db2: 0x11ed, 0x0db3: 0x12a1, 0x0db4: 0x12c9, 0x0db5: 0x133d,
+ 0x0db6: 0x1385, 0x0db7: 0x1391, 0x0db8: 0x1399, 0x0db9: 0x13b1, 0x0dba: 0x13c5, 0x0dbb: 0x13b5,
+ 0x0dbc: 0x13cd, 0x0dbd: 0x13c9, 0x0dbe: 0x13c1, 0x0dbf: 0x13d1,
+ // Block 0x37, offset 0xdc0
+ 0x0dc0: 0x13dd, 0x0dc1: 0x1419, 0x0dc2: 0x1455, 0x0dc3: 0x1485, 0x0dc4: 0x14b9, 0x0dc5: 0x14d9,
+ 0x0dc6: 0x1525, 0x0dc7: 0x1549, 0x0dc8: 0x1569, 0x0dc9: 0x157d, 0x0dca: 0x158d, 0x0dcb: 0x1599,
+ 0x0dcc: 0x15a5, 0x0dcd: 0x15f9, 0x0dce: 0x1699, 0x0dcf: 0x1717, 0x0dd0: 0x1712, 0x0dd1: 0x1744,
+ 0x0dd2: 0x0679, 0x0dd3: 0x06a1, 0x0dd4: 0x06a5, 0x0dd5: 0x17c6, 0x0dd6: 0x17f3, 0x0dd7: 0x186b,
+ 0x0dd8: 0x1685, 0x0dd9: 0x1695,
+ // Block 0x38, offset 0xe00
+ 0x0e00: 0x1b17, 0x0e01: 0x1b1a, 0x0e02: 0x1b1d, 0x0e03: 0x1d4a, 0x0e04: 0x1d4e, 0x0e05: 0x1ba1,
+ 0x0e06: 0x1ba1,
+ 0x0e13: 0x1eb7, 0x0e14: 0x1ea8, 0x0e15: 0x1ead, 0x0e16: 0x1ebc, 0x0e17: 0x1eb2,
+ 0x0e1d: 0x4376,
+ 0x0e1e: 0x801a, 0x0e1f: 0x43e8, 0x0e20: 0x0227, 0x0e21: 0x020f, 0x0e22: 0x0218, 0x0e23: 0x021b,
+ 0x0e24: 0x021e, 0x0e25: 0x0221, 0x0e26: 0x0224, 0x0e27: 0x022a, 0x0e28: 0x022d, 0x0e29: 0x0017,
+ 0x0e2a: 0x43d6, 0x0e2b: 0x43dc, 0x0e2c: 0x44da, 0x0e2d: 0x44e2, 0x0e2e: 0x432e, 0x0e2f: 0x4334,
+ 0x0e30: 0x433a, 0x0e31: 0x4340, 0x0e32: 0x434c, 0x0e33: 0x4352, 0x0e34: 0x4358, 0x0e35: 0x4364,
+ 0x0e36: 0x436a, 0x0e38: 0x4370, 0x0e39: 0x437c, 0x0e3a: 0x4382, 0x0e3b: 0x4388,
+ 0x0e3c: 0x4394, 0x0e3e: 0x439a,
+ // Block 0x39, offset 0xe40
+ 0x0e40: 0x43a0, 0x0e41: 0x43a6, 0x0e43: 0x43ac, 0x0e44: 0x43b2,
+ 0x0e46: 0x43be, 0x0e47: 0x43c4, 0x0e48: 0x43ca, 0x0e49: 0x43d0, 0x0e4a: 0x43e2, 0x0e4b: 0x435e,
+ 0x0e4c: 0x4346, 0x0e4d: 0x438e, 0x0e4e: 0x43b8, 0x0e4f: 0x1ec1, 0x0e50: 0x0293, 0x0e51: 0x0293,
+ 0x0e52: 0x029c, 0x0e53: 0x029c, 0x0e54: 0x029c, 0x0e55: 0x029c, 0x0e56: 0x029f, 0x0e57: 0x029f,
+ 0x0e58: 0x029f, 0x0e59: 0x029f, 0x0e5a: 0x02a5, 0x0e5b: 0x02a5, 0x0e5c: 0x02a5, 0x0e5d: 0x02a5,
+ 0x0e5e: 0x0299, 0x0e5f: 0x0299, 0x0e60: 0x0299, 0x0e61: 0x0299, 0x0e62: 0x02a2, 0x0e63: 0x02a2,
+ 0x0e64: 0x02a2, 0x0e65: 0x02a2, 0x0e66: 0x0296, 0x0e67: 0x0296, 0x0e68: 0x0296, 0x0e69: 0x0296,
+ 0x0e6a: 0x02c9, 0x0e6b: 0x02c9, 0x0e6c: 0x02c9, 0x0e6d: 0x02c9, 0x0e6e: 0x02cc, 0x0e6f: 0x02cc,
+ 0x0e70: 0x02cc, 0x0e71: 0x02cc, 0x0e72: 0x02ab, 0x0e73: 0x02ab, 0x0e74: 0x02ab, 0x0e75: 0x02ab,
+ 0x0e76: 0x02a8, 0x0e77: 0x02a8, 0x0e78: 0x02a8, 0x0e79: 0x02a8, 0x0e7a: 0x02ae, 0x0e7b: 0x02ae,
+ 0x0e7c: 0x02ae, 0x0e7d: 0x02ae, 0x0e7e: 0x02b1, 0x0e7f: 0x02b1,
+ // Block 0x3a, offset 0xe80
+ 0x0e80: 0x02b1, 0x0e81: 0x02b1, 0x0e82: 0x02ba, 0x0e83: 0x02ba, 0x0e84: 0x02b7, 0x0e85: 0x02b7,
+ 0x0e86: 0x02bd, 0x0e87: 0x02bd, 0x0e88: 0x02b4, 0x0e89: 0x02b4, 0x0e8a: 0x02c3, 0x0e8b: 0x02c3,
+ 0x0e8c: 0x02c0, 0x0e8d: 0x02c0, 0x0e8e: 0x02cf, 0x0e8f: 0x02cf, 0x0e90: 0x02cf, 0x0e91: 0x02cf,
+ 0x0e92: 0x02d5, 0x0e93: 0x02d5, 0x0e94: 0x02d5, 0x0e95: 0x02d5, 0x0e96: 0x02db, 0x0e97: 0x02db,
+ 0x0e98: 0x02db, 0x0e99: 0x02db, 0x0e9a: 0x02d8, 0x0e9b: 0x02d8, 0x0e9c: 0x02d8, 0x0e9d: 0x02d8,
+ 0x0e9e: 0x02de, 0x0e9f: 0x02de, 0x0ea0: 0x02e1, 0x0ea1: 0x02e1, 0x0ea2: 0x02e1, 0x0ea3: 0x02e1,
+ 0x0ea4: 0x4454, 0x0ea5: 0x4454, 0x0ea6: 0x02e7, 0x0ea7: 0x02e7, 0x0ea8: 0x02e7, 0x0ea9: 0x02e7,
+ 0x0eaa: 0x02e4, 0x0eab: 0x02e4, 0x0eac: 0x02e4, 0x0ead: 0x02e4, 0x0eae: 0x0302, 0x0eaf: 0x0302,
+ 0x0eb0: 0x444e, 0x0eb1: 0x444e,
+ // Block 0x3b, offset 0xec0
+ 0x0ed3: 0x02d2, 0x0ed4: 0x02d2, 0x0ed5: 0x02d2, 0x0ed6: 0x02d2, 0x0ed7: 0x02f0,
+ 0x0ed8: 0x02f0, 0x0ed9: 0x02ed, 0x0eda: 0x02ed, 0x0edb: 0x02f3, 0x0edc: 0x02f3, 0x0edd: 0x2191,
+ 0x0ede: 0x02f9, 0x0edf: 0x02f9, 0x0ee0: 0x02ea, 0x0ee1: 0x02ea, 0x0ee2: 0x02f6, 0x0ee3: 0x02f6,
+ 0x0ee4: 0x02ff, 0x0ee5: 0x02ff, 0x0ee6: 0x02ff, 0x0ee7: 0x02ff, 0x0ee8: 0x0287, 0x0ee9: 0x0287,
+ 0x0eea: 0x26ec, 0x0eeb: 0x26ec, 0x0eec: 0x275c, 0x0eed: 0x275c, 0x0eee: 0x272b, 0x0eef: 0x272b,
+ 0x0ef0: 0x2747, 0x0ef1: 0x2747, 0x0ef2: 0x2740, 0x0ef3: 0x2740, 0x0ef4: 0x274e, 0x0ef5: 0x274e,
+ 0x0ef6: 0x2755, 0x0ef7: 0x2755, 0x0ef8: 0x2755, 0x0ef9: 0x2732, 0x0efa: 0x2732, 0x0efb: 0x2732,
+ 0x0efc: 0x02fc, 0x0efd: 0x02fc, 0x0efe: 0x02fc, 0x0eff: 0x02fc,
+ // Block 0x3c, offset 0xf00
+ 0x0f00: 0x26f3, 0x0f01: 0x26fa, 0x0f02: 0x2716, 0x0f03: 0x2732, 0x0f04: 0x2739, 0x0f05: 0x1ecb,
+ 0x0f06: 0x1ed0, 0x0f07: 0x1ed5, 0x0f08: 0x1ee4, 0x0f09: 0x1ef3, 0x0f0a: 0x1ef8, 0x0f0b: 0x1efd,
+ 0x0f0c: 0x1f02, 0x0f0d: 0x1f07, 0x0f0e: 0x1f16, 0x0f0f: 0x1f25, 0x0f10: 0x1f2a, 0x0f11: 0x1f2f,
+ 0x0f12: 0x1f3e, 0x0f13: 0x1f4d, 0x0f14: 0x1f52, 0x0f15: 0x1f57, 0x0f16: 0x1f5c, 0x0f17: 0x1f6b,
+ 0x0f18: 0x1f70, 0x0f19: 0x1f7f, 0x0f1a: 0x1f84, 0x0f1b: 0x1f89, 0x0f1c: 0x1f98, 0x0f1d: 0x1f9d,
+ 0x0f1e: 0x1fa2, 0x0f1f: 0x1fac, 0x0f20: 0x1fe8, 0x0f21: 0x1ff7, 0x0f22: 0x2006, 0x0f23: 0x200b,
+ 0x0f24: 0x2010, 0x0f25: 0x201a, 0x0f26: 0x2029, 0x0f27: 0x202e, 0x0f28: 0x203d, 0x0f29: 0x2042,
+ 0x0f2a: 0x2047, 0x0f2b: 0x2056, 0x0f2c: 0x205b, 0x0f2d: 0x206a, 0x0f2e: 0x206f, 0x0f2f: 0x2074,
+ 0x0f30: 0x2079, 0x0f31: 0x207e, 0x0f32: 0x2083, 0x0f33: 0x2088, 0x0f34: 0x208d, 0x0f35: 0x2092,
+ 0x0f36: 0x2097, 0x0f37: 0x209c, 0x0f38: 0x20a1, 0x0f39: 0x20a6, 0x0f3a: 0x20ab, 0x0f3b: 0x20b0,
+ 0x0f3c: 0x20b5, 0x0f3d: 0x20ba, 0x0f3e: 0x20bf, 0x0f3f: 0x20c9,
+ // Block 0x3d, offset 0xf40
+ 0x0f40: 0x20ce, 0x0f41: 0x20d3, 0x0f42: 0x20d8, 0x0f43: 0x20e2, 0x0f44: 0x20e7, 0x0f45: 0x20f1,
+ 0x0f46: 0x20f6, 0x0f47: 0x20fb, 0x0f48: 0x2100, 0x0f49: 0x2105, 0x0f4a: 0x210a, 0x0f4b: 0x210f,
+ 0x0f4c: 0x2114, 0x0f4d: 0x2119, 0x0f4e: 0x2128, 0x0f4f: 0x2137, 0x0f50: 0x213c, 0x0f51: 0x2141,
+ 0x0f52: 0x2146, 0x0f53: 0x214b, 0x0f54: 0x2150, 0x0f55: 0x215a, 0x0f56: 0x215f, 0x0f57: 0x2164,
+ 0x0f58: 0x2173, 0x0f59: 0x2182, 0x0f5a: 0x2187, 0x0f5b: 0x4406, 0x0f5c: 0x440c, 0x0f5d: 0x4442,
+ 0x0f5e: 0x4499, 0x0f5f: 0x44a0, 0x0f60: 0x44a7, 0x0f61: 0x44ae, 0x0f62: 0x44b5, 0x0f63: 0x44bc,
+ 0x0f64: 0x2708, 0x0f65: 0x270f, 0x0f66: 0x2716, 0x0f67: 0x271d, 0x0f68: 0x2732, 0x0f69: 0x2739,
+ 0x0f6a: 0x1eda, 0x0f6b: 0x1edf, 0x0f6c: 0x1ee4, 0x0f6d: 0x1ee9, 0x0f6e: 0x1ef3, 0x0f6f: 0x1ef8,
+ 0x0f70: 0x1f0c, 0x0f71: 0x1f11, 0x0f72: 0x1f16, 0x0f73: 0x1f1b, 0x0f74: 0x1f25, 0x0f75: 0x1f2a,
+ 0x0f76: 0x1f34, 0x0f77: 0x1f39, 0x0f78: 0x1f3e, 0x0f79: 0x1f43, 0x0f7a: 0x1f4d, 0x0f7b: 0x1f52,
+ 0x0f7c: 0x207e, 0x0f7d: 0x2083, 0x0f7e: 0x2092, 0x0f7f: 0x2097,
+ // Block 0x3e, offset 0xf80
+ 0x0f80: 0x209c, 0x0f81: 0x20b0, 0x0f82: 0x20b5, 0x0f83: 0x20ba, 0x0f84: 0x20bf, 0x0f85: 0x20d8,
+ 0x0f86: 0x20e2, 0x0f87: 0x20e7, 0x0f88: 0x20ec, 0x0f89: 0x2100, 0x0f8a: 0x211e, 0x0f8b: 0x2123,
+ 0x0f8c: 0x2128, 0x0f8d: 0x212d, 0x0f8e: 0x2137, 0x0f8f: 0x213c, 0x0f90: 0x4442, 0x0f91: 0x2169,
+ 0x0f92: 0x216e, 0x0f93: 0x2173, 0x0f94: 0x2178, 0x0f95: 0x2182, 0x0f96: 0x2187, 0x0f97: 0x26f3,
+ 0x0f98: 0x26fa, 0x0f99: 0x2701, 0x0f9a: 0x2716, 0x0f9b: 0x2724, 0x0f9c: 0x1ecb, 0x0f9d: 0x1ed0,
+ 0x0f9e: 0x1ed5, 0x0f9f: 0x1ee4, 0x0fa0: 0x1eee, 0x0fa1: 0x1efd, 0x0fa2: 0x1f02, 0x0fa3: 0x1f07,
+ 0x0fa4: 0x1f16, 0x0fa5: 0x1f20, 0x0fa6: 0x1f3e, 0x0fa7: 0x1f57, 0x0fa8: 0x1f5c, 0x0fa9: 0x1f6b,
+ 0x0faa: 0x1f70, 0x0fab: 0x1f7f, 0x0fac: 0x1f89, 0x0fad: 0x1f98, 0x0fae: 0x1f9d, 0x0faf: 0x1fa2,
+ 0x0fb0: 0x1fac, 0x0fb1: 0x1fe8, 0x0fb2: 0x1fed, 0x0fb3: 0x1ff7, 0x0fb4: 0x2006, 0x0fb5: 0x200b,
+ 0x0fb6: 0x2010, 0x0fb7: 0x201a, 0x0fb8: 0x2029, 0x0fb9: 0x203d, 0x0fba: 0x2042, 0x0fbb: 0x2047,
+ 0x0fbc: 0x2056, 0x0fbd: 0x205b, 0x0fbe: 0x206a, 0x0fbf: 0x206f,
+ // Block 0x3f, offset 0xfc0
+ 0x0fc0: 0x2074, 0x0fc1: 0x2079, 0x0fc2: 0x2088, 0x0fc3: 0x208d, 0x0fc4: 0x20a1, 0x0fc5: 0x20a6,
+ 0x0fc6: 0x20ab, 0x0fc7: 0x20b0, 0x0fc8: 0x20b5, 0x0fc9: 0x20c9, 0x0fca: 0x20ce, 0x0fcb: 0x20d3,
+ 0x0fcc: 0x20d8, 0x0fcd: 0x20dd, 0x0fce: 0x20f1, 0x0fcf: 0x20f6, 0x0fd0: 0x20fb, 0x0fd1: 0x2100,
+ 0x0fd2: 0x210f, 0x0fd3: 0x2114, 0x0fd4: 0x2119, 0x0fd5: 0x2128, 0x0fd6: 0x2132, 0x0fd7: 0x2141,
+ 0x0fd8: 0x2146, 0x0fd9: 0x4436, 0x0fda: 0x215a, 0x0fdb: 0x215f, 0x0fdc: 0x2164, 0x0fdd: 0x2173,
+ 0x0fde: 0x217d, 0x0fdf: 0x2716, 0x0fe0: 0x2724, 0x0fe1: 0x1ee4, 0x0fe2: 0x1eee, 0x0fe3: 0x1f16,
+ 0x0fe4: 0x1f20, 0x0fe5: 0x1f3e, 0x0fe6: 0x1f48, 0x0fe7: 0x1fac, 0x0fe8: 0x1fb1, 0x0fe9: 0x1fd4,
+ 0x0fea: 0x1fd9, 0x0feb: 0x20b0, 0x0fec: 0x20b5, 0x0fed: 0x20d8, 0x0fee: 0x2128, 0x0fef: 0x2132,
+ 0x0ff0: 0x2173, 0x0ff1: 0x217d, 0x0ff2: 0x44ea, 0x0ff3: 0x44f2, 0x0ff4: 0x44fa, 0x0ff5: 0x2033,
+ 0x0ff6: 0x2038, 0x0ff7: 0x204c, 0x0ff8: 0x2051, 0x0ff9: 0x2060, 0x0ffa: 0x2065, 0x0ffb: 0x1fb6,
+ 0x0ffc: 0x1fbb, 0x0ffd: 0x1fde, 0x0ffe: 0x1fe3, 0x0fff: 0x1f75,
+ // Block 0x40, offset 0x1000
+ 0x1000: 0x1f7a, 0x1001: 0x1f61, 0x1002: 0x1f66, 0x1003: 0x1f8e, 0x1004: 0x1f93, 0x1005: 0x1ffc,
+ 0x1006: 0x2001, 0x1007: 0x201f, 0x1008: 0x2024, 0x1009: 0x1fc0, 0x100a: 0x1fc5, 0x100b: 0x1fca,
+ 0x100c: 0x1fd4, 0x100d: 0x1fcf, 0x100e: 0x1fa7, 0x100f: 0x1ff2, 0x1010: 0x2015, 0x1011: 0x2033,
+ 0x1012: 0x2038, 0x1013: 0x204c, 0x1014: 0x2051, 0x1015: 0x2060, 0x1016: 0x2065, 0x1017: 0x1fb6,
+ 0x1018: 0x1fbb, 0x1019: 0x1fde, 0x101a: 0x1fe3, 0x101b: 0x1f75, 0x101c: 0x1f7a, 0x101d: 0x1f61,
+ 0x101e: 0x1f66, 0x101f: 0x1f8e, 0x1020: 0x1f93, 0x1021: 0x1ffc, 0x1022: 0x2001, 0x1023: 0x201f,
+ 0x1024: 0x2024, 0x1025: 0x1fc0, 0x1026: 0x1fc5, 0x1027: 0x1fca, 0x1028: 0x1fd4, 0x1029: 0x1fcf,
+ 0x102a: 0x1fa7, 0x102b: 0x1ff2, 0x102c: 0x2015, 0x102d: 0x1fc0, 0x102e: 0x1fc5, 0x102f: 0x1fca,
+ 0x1030: 0x1fd4, 0x1031: 0x1fb1, 0x1032: 0x1fd9, 0x1033: 0x202e, 0x1034: 0x1f98, 0x1035: 0x1f9d,
+ 0x1036: 0x1fa2, 0x1037: 0x1fc0, 0x1038: 0x1fc5, 0x1039: 0x1fca, 0x103a: 0x202e, 0x103b: 0x203d,
+ 0x103c: 0x43ee, 0x103d: 0x43ee,
+ // Block 0x41, offset 0x1040
+ 0x1050: 0x2453, 0x1051: 0x2468,
+ 0x1052: 0x2468, 0x1053: 0x246f, 0x1054: 0x2476, 0x1055: 0x248b, 0x1056: 0x2492, 0x1057: 0x2499,
+ 0x1058: 0x24bc, 0x1059: 0x24bc, 0x105a: 0x24df, 0x105b: 0x24d8, 0x105c: 0x24f4, 0x105d: 0x24e6,
+ 0x105e: 0x24ed, 0x105f: 0x2510, 0x1060: 0x2510, 0x1061: 0x2509, 0x1062: 0x2517, 0x1063: 0x2517,
+ 0x1064: 0x2541, 0x1065: 0x2541, 0x1066: 0x255d, 0x1067: 0x2525, 0x1068: 0x2525, 0x1069: 0x251e,
+ 0x106a: 0x2533, 0x106b: 0x2533, 0x106c: 0x253a, 0x106d: 0x253a, 0x106e: 0x2564, 0x106f: 0x2572,
+ 0x1070: 0x2572, 0x1071: 0x2579, 0x1072: 0x2579, 0x1073: 0x2580, 0x1074: 0x2587, 0x1075: 0x258e,
+ 0x1076: 0x2595, 0x1077: 0x2595, 0x1078: 0x259c, 0x1079: 0x25aa, 0x107a: 0x25b8, 0x107b: 0x25b1,
+ 0x107c: 0x25bf, 0x107d: 0x25bf, 0x107e: 0x25d4, 0x107f: 0x25db,
+ // Block 0x42, offset 0x1080
+ 0x1080: 0x260c, 0x1081: 0x261a, 0x1082: 0x2613, 0x1083: 0x25f7, 0x1084: 0x25f7, 0x1085: 0x2621,
+ 0x1086: 0x2621, 0x1087: 0x2628, 0x1088: 0x2628, 0x1089: 0x2652, 0x108a: 0x2659, 0x108b: 0x2660,
+ 0x108c: 0x2636, 0x108d: 0x2644, 0x108e: 0x2667, 0x108f: 0x266e,
+ 0x1092: 0x263d, 0x1093: 0x26c2, 0x1094: 0x26c9, 0x1095: 0x269f, 0x1096: 0x26a6, 0x1097: 0x268a,
+ 0x1098: 0x268a, 0x1099: 0x2691, 0x109a: 0x26bb, 0x109b: 0x26b4, 0x109c: 0x26de, 0x109d: 0x26de,
+ 0x109e: 0x244c, 0x109f: 0x2461, 0x10a0: 0x245a, 0x10a1: 0x2484, 0x10a2: 0x247d, 0x10a3: 0x24a7,
+ 0x10a4: 0x24a0, 0x10a5: 0x24ca, 0x10a6: 0x24ae, 0x10a7: 0x24c3, 0x10a8: 0x24fb, 0x10a9: 0x2548,
+ 0x10aa: 0x252c, 0x10ab: 0x256b, 0x10ac: 0x2605, 0x10ad: 0x262f, 0x10ae: 0x26d7, 0x10af: 0x26d0,
+ 0x10b0: 0x26e5, 0x10b1: 0x267c, 0x10b2: 0x25e2, 0x10b3: 0x26ad, 0x10b4: 0x25d4, 0x10b5: 0x260c,
+ 0x10b6: 0x25a3, 0x10b7: 0x25f0, 0x10b8: 0x2683, 0x10b9: 0x2675, 0x10ba: 0x25fe, 0x10bb: 0x25e9,
+ 0x10bc: 0x25fe, 0x10bd: 0x2683, 0x10be: 0x24b5, 0x10bf: 0x24d1,
+ // Block 0x43, offset 0x10c0
+ 0x10c0: 0x264b, 0x10c1: 0x25c6, 0x10c2: 0x2445, 0x10c3: 0x25e9, 0x10c4: 0x258e, 0x10c5: 0x255d,
+ 0x10c6: 0x2502, 0x10c7: 0x2698,
+ 0x10f0: 0x2556, 0x10f1: 0x25cd, 0x10f2: 0x296a, 0x10f3: 0x2961, 0x10f4: 0x2997, 0x10f5: 0x2985,
+ 0x10f6: 0x2973, 0x10f7: 0x298e, 0x10f8: 0x29a0, 0x10f9: 0x254f, 0x10fa: 0x2e44, 0x10fb: 0x2cb4,
+ 0x10fc: 0x297c,
+ // Block 0x44, offset 0x1100
+ 0x1110: 0x0019, 0x1111: 0x04f5,
+ 0x1112: 0x04f9, 0x1113: 0x0035, 0x1114: 0x0037, 0x1115: 0x0003, 0x1116: 0x003f, 0x1117: 0x0531,
+ 0x1118: 0x0535, 0x1119: 0x1c9e,
+ 0x1120: 0x80e6, 0x1121: 0x80e6, 0x1122: 0x80e6, 0x1123: 0x80e6,
+ 0x1124: 0x80e6, 0x1125: 0x80e6, 0x1126: 0x80e6,
+ 0x1130: 0x19b5, 0x1131: 0x04b5, 0x1132: 0x04b1, 0x1133: 0x007f, 0x1134: 0x007f, 0x1135: 0x0011,
+ 0x1136: 0x0013, 0x1137: 0x00b7, 0x1138: 0x00bb, 0x1139: 0x0529, 0x113a: 0x052d, 0x113b: 0x051d,
+ 0x113c: 0x0521, 0x113d: 0x0505, 0x113e: 0x0509, 0x113f: 0x04fd,
+ // Block 0x45, offset 0x1140
+ 0x1140: 0x0501, 0x1141: 0x050d, 0x1142: 0x0511, 0x1143: 0x0515, 0x1144: 0x0519,
+ 0x1147: 0x0077, 0x1148: 0x007b, 0x1149: 0x424f, 0x114a: 0x424f, 0x114b: 0x424f,
+ 0x114c: 0x424f, 0x114d: 0x007f, 0x114e: 0x007f, 0x114f: 0x007f, 0x1150: 0x0019, 0x1151: 0x04f5,
+ 0x1152: 0x001d, 0x1154: 0x0037, 0x1155: 0x0035, 0x1156: 0x003f, 0x1157: 0x0003,
+ 0x1158: 0x04b5, 0x1159: 0x0011, 0x115a: 0x0013, 0x115b: 0x00b7, 0x115c: 0x00bb, 0x115d: 0x0529,
+ 0x115e: 0x052d, 0x115f: 0x0007, 0x1160: 0x000d, 0x1161: 0x0015, 0x1162: 0x0017, 0x1163: 0x001b,
+ 0x1164: 0x0039, 0x1165: 0x003d, 0x1166: 0x003b, 0x1168: 0x0079, 0x1169: 0x0009,
+ 0x116a: 0x000b, 0x116b: 0x0041,
+ 0x1170: 0x4290, 0x1171: 0x4412, 0x1172: 0x4295, 0x1174: 0x429a,
+ 0x1176: 0x429f, 0x1177: 0x4418, 0x1178: 0x42a4, 0x1179: 0x441e, 0x117a: 0x42a9, 0x117b: 0x4424,
+ 0x117c: 0x42ae, 0x117d: 0x442a, 0x117e: 0x42b3, 0x117f: 0x4430,
+ // Block 0x46, offset 0x1180
+ 0x1180: 0x0230, 0x1181: 0x43f4, 0x1182: 0x43f4, 0x1183: 0x43fa, 0x1184: 0x43fa, 0x1185: 0x443c,
+ 0x1186: 0x443c, 0x1187: 0x4400, 0x1188: 0x4400, 0x1189: 0x4448, 0x118a: 0x4448, 0x118b: 0x4448,
+ 0x118c: 0x4448, 0x118d: 0x0233, 0x118e: 0x0233, 0x118f: 0x0236, 0x1190: 0x0236, 0x1191: 0x0236,
+ 0x1192: 0x0236, 0x1193: 0x0239, 0x1194: 0x0239, 0x1195: 0x023c, 0x1196: 0x023c, 0x1197: 0x023c,
+ 0x1198: 0x023c, 0x1199: 0x023f, 0x119a: 0x023f, 0x119b: 0x023f, 0x119c: 0x023f, 0x119d: 0x0242,
+ 0x119e: 0x0242, 0x119f: 0x0242, 0x11a0: 0x0242, 0x11a1: 0x0245, 0x11a2: 0x0245, 0x11a3: 0x0245,
+ 0x11a4: 0x0245, 0x11a5: 0x0248, 0x11a6: 0x0248, 0x11a7: 0x0248, 0x11a8: 0x0248, 0x11a9: 0x024b,
+ 0x11aa: 0x024b, 0x11ab: 0x024e, 0x11ac: 0x024e, 0x11ad: 0x0251, 0x11ae: 0x0251, 0x11af: 0x0254,
+ 0x11b0: 0x0254, 0x11b1: 0x0257, 0x11b2: 0x0257, 0x11b3: 0x0257, 0x11b4: 0x0257, 0x11b5: 0x025a,
+ 0x11b6: 0x025a, 0x11b7: 0x025a, 0x11b8: 0x025a, 0x11b9: 0x025d, 0x11ba: 0x025d, 0x11bb: 0x025d,
+ 0x11bc: 0x025d, 0x11bd: 0x0260, 0x11be: 0x0260, 0x11bf: 0x0260,
+ // Block 0x47, offset 0x11c0
+ 0x11c0: 0x0260, 0x11c1: 0x0263, 0x11c2: 0x0263, 0x11c3: 0x0263, 0x11c4: 0x0263, 0x11c5: 0x0266,
+ 0x11c6: 0x0266, 0x11c7: 0x0266, 0x11c8: 0x0266, 0x11c9: 0x0269, 0x11ca: 0x0269, 0x11cb: 0x0269,
+ 0x11cc: 0x0269, 0x11cd: 0x026c, 0x11ce: 0x026c, 0x11cf: 0x026c, 0x11d0: 0x026c, 0x11d1: 0x026f,
+ 0x11d2: 0x026f, 0x11d3: 0x026f, 0x11d4: 0x026f, 0x11d5: 0x0272, 0x11d6: 0x0272, 0x11d7: 0x0272,
+ 0x11d8: 0x0272, 0x11d9: 0x0275, 0x11da: 0x0275, 0x11db: 0x0275, 0x11dc: 0x0275, 0x11dd: 0x0278,
+ 0x11de: 0x0278, 0x11df: 0x0278, 0x11e0: 0x0278, 0x11e1: 0x027b, 0x11e2: 0x027b, 0x11e3: 0x027b,
+ 0x11e4: 0x027b, 0x11e5: 0x027e, 0x11e6: 0x027e, 0x11e7: 0x027e, 0x11e8: 0x027e, 0x11e9: 0x0281,
+ 0x11ea: 0x0281, 0x11eb: 0x0281, 0x11ec: 0x0281, 0x11ed: 0x0284, 0x11ee: 0x0284, 0x11ef: 0x0287,
+ 0x11f0: 0x0287, 0x11f1: 0x028a, 0x11f2: 0x028a, 0x11f3: 0x028a, 0x11f4: 0x028a, 0x11f5: 0x2e91,
+ 0x11f6: 0x2e91, 0x11f7: 0x2e99, 0x11f8: 0x2e99, 0x11f9: 0x2ea1, 0x11fa: 0x2ea1, 0x11fb: 0x20c4,
+ 0x11fc: 0x20c4,
+ // Block 0x48, offset 0x1200
+ 0x1200: 0x0081, 0x1201: 0x0083, 0x1202: 0x0085, 0x1203: 0x0087, 0x1204: 0x0089, 0x1205: 0x008b,
+ 0x1206: 0x008d, 0x1207: 0x008f, 0x1208: 0x0091, 0x1209: 0x0093, 0x120a: 0x0095, 0x120b: 0x0097,
+ 0x120c: 0x0099, 0x120d: 0x009b, 0x120e: 0x009d, 0x120f: 0x009f, 0x1210: 0x00a1, 0x1211: 0x00a3,
+ 0x1212: 0x00a5, 0x1213: 0x00a7, 0x1214: 0x00a9, 0x1215: 0x00ab, 0x1216: 0x00ad, 0x1217: 0x00af,
+ 0x1218: 0x00b1, 0x1219: 0x00b3, 0x121a: 0x00b5, 0x121b: 0x00b7, 0x121c: 0x00b9, 0x121d: 0x00bb,
+ 0x121e: 0x00bd, 0x121f: 0x04e9, 0x1220: 0x04ed, 0x1221: 0x04f9, 0x1222: 0x050d, 0x1223: 0x0511,
+ 0x1224: 0x04f5, 0x1225: 0x061d, 0x1226: 0x0615, 0x1227: 0x0539, 0x1228: 0x0541, 0x1229: 0x0549,
+ 0x122a: 0x0551, 0x122b: 0x0559, 0x122c: 0x05dd, 0x122d: 0x05e5, 0x122e: 0x05ed, 0x122f: 0x0591,
+ 0x1230: 0x0621, 0x1231: 0x053d, 0x1232: 0x0545, 0x1233: 0x054d, 0x1234: 0x0555, 0x1235: 0x055d,
+ 0x1236: 0x0561, 0x1237: 0x0565, 0x1238: 0x0569, 0x1239: 0x056d, 0x123a: 0x0571, 0x123b: 0x0575,
+ 0x123c: 0x0579, 0x123d: 0x057d, 0x123e: 0x0581, 0x123f: 0x0585,
+ // Block 0x49, offset 0x1240
+ 0x1240: 0x0589, 0x1241: 0x058d, 0x1242: 0x0595, 0x1243: 0x0599, 0x1244: 0x059d, 0x1245: 0x05a1,
+ 0x1246: 0x05a5, 0x1247: 0x05a9, 0x1248: 0x05ad, 0x1249: 0x05b1, 0x124a: 0x05b5, 0x124b: 0x05b9,
+ 0x124c: 0x05bd, 0x124d: 0x05c1, 0x124e: 0x05c5, 0x124f: 0x05c9, 0x1250: 0x05cd, 0x1251: 0x05d1,
+ 0x1252: 0x05d5, 0x1253: 0x05d9, 0x1254: 0x05e1, 0x1255: 0x05e9, 0x1256: 0x05f1, 0x1257: 0x05f5,
+ 0x1258: 0x05f9, 0x1259: 0x05fd, 0x125a: 0x0601, 0x125b: 0x0605, 0x125c: 0x0609, 0x125d: 0x0619,
+ 0x125e: 0x49aa, 0x125f: 0x49b0, 0x1260: 0x03bd, 0x1261: 0x030d, 0x1262: 0x0311, 0x1263: 0x0435,
+ 0x1264: 0x0315, 0x1265: 0x0439, 0x1266: 0x043d, 0x1267: 0x0319, 0x1268: 0x031d, 0x1269: 0x0321,
+ 0x126a: 0x0441, 0x126b: 0x0445, 0x126c: 0x0449, 0x126d: 0x044d, 0x126e: 0x0451, 0x126f: 0x0455,
+ 0x1270: 0x0361, 0x1271: 0x0325, 0x1272: 0x0329, 0x1273: 0x032d, 0x1274: 0x0375, 0x1275: 0x0331,
+ 0x1276: 0x0335, 0x1277: 0x0339, 0x1278: 0x033d, 0x1279: 0x0341, 0x127a: 0x0345, 0x127b: 0x0349,
+ 0x127c: 0x034d, 0x127d: 0x0351, 0x127e: 0x0355,
+ // Block 0x4a, offset 0x1280
+ 0x1280: 0x0063, 0x1281: 0x0065, 0x1282: 0x0067, 0x1283: 0x0069, 0x1284: 0x006b, 0x1285: 0x006d,
+ 0x1286: 0x006f, 0x1287: 0x0071, 0x1288: 0x0073, 0x1289: 0x0075, 0x128a: 0x0083, 0x128b: 0x0085,
+ 0x128c: 0x0087, 0x128d: 0x0089, 0x128e: 0x008b, 0x128f: 0x008d, 0x1290: 0x008f, 0x1291: 0x0091,
+ 0x1292: 0x0093, 0x1293: 0x0095, 0x1294: 0x0097, 0x1295: 0x0099, 0x1296: 0x009b, 0x1297: 0x009d,
+ 0x1298: 0x009f, 0x1299: 0x00a1, 0x129a: 0x00a3, 0x129b: 0x00a5, 0x129c: 0x00a7, 0x129d: 0x00a9,
+ 0x129e: 0x00ab, 0x129f: 0x00ad, 0x12a0: 0x00af, 0x12a1: 0x00b1, 0x12a2: 0x00b3, 0x12a3: 0x00b5,
+ 0x12a4: 0x00e0, 0x12a5: 0x00f5, 0x12a8: 0x0173, 0x12a9: 0x0176,
+ 0x12aa: 0x0179, 0x12ab: 0x017c, 0x12ac: 0x017f, 0x12ad: 0x0182, 0x12ae: 0x0185, 0x12af: 0x0188,
+ 0x12b0: 0x018b, 0x12b1: 0x018e, 0x12b2: 0x0191, 0x12b3: 0x0194, 0x12b4: 0x0197, 0x12b5: 0x019a,
+ 0x12b6: 0x019d, 0x12b7: 0x01a0, 0x12b8: 0x01a3, 0x12b9: 0x0188, 0x12ba: 0x01a6, 0x12bb: 0x01a9,
+ 0x12bc: 0x01ac, 0x12bd: 0x01af, 0x12be: 0x01b2, 0x12bf: 0x01b5,
+ // Block 0x4b, offset 0x12c0
+ 0x12c0: 0x01fd, 0x12c1: 0x0200, 0x12c2: 0x0203, 0x12c3: 0x04cd, 0x12c4: 0x01c7, 0x12c5: 0x01d0,
+ 0x12c6: 0x01d6, 0x12c7: 0x01fa, 0x12c8: 0x01eb, 0x12c9: 0x01e8, 0x12ca: 0x0206, 0x12cb: 0x0209,
+ 0x12ce: 0x0021, 0x12cf: 0x0023, 0x12d0: 0x0025, 0x12d1: 0x0027,
+ 0x12d2: 0x0029, 0x12d3: 0x002b, 0x12d4: 0x002d, 0x12d5: 0x002f, 0x12d6: 0x0031, 0x12d7: 0x0033,
+ 0x12d8: 0x0021, 0x12d9: 0x0023, 0x12da: 0x0025, 0x12db: 0x0027, 0x12dc: 0x0029, 0x12dd: 0x002b,
+ 0x12de: 0x002d, 0x12df: 0x002f, 0x12e0: 0x0031, 0x12e1: 0x0033, 0x12e2: 0x0021, 0x12e3: 0x0023,
+ 0x12e4: 0x0025, 0x12e5: 0x0027, 0x12e6: 0x0029, 0x12e7: 0x002b, 0x12e8: 0x002d, 0x12e9: 0x002f,
+ 0x12ea: 0x0031, 0x12eb: 0x0033, 0x12ec: 0x0021, 0x12ed: 0x0023, 0x12ee: 0x0025, 0x12ef: 0x0027,
+ 0x12f0: 0x0029, 0x12f1: 0x002b, 0x12f2: 0x002d, 0x12f3: 0x002f, 0x12f4: 0x0031, 0x12f5: 0x0033,
+ 0x12f6: 0x0021, 0x12f7: 0x0023, 0x12f8: 0x0025, 0x12f9: 0x0027, 0x12fa: 0x0029, 0x12fb: 0x002b,
+ 0x12fc: 0x002d, 0x12fd: 0x002f, 0x12fe: 0x0031, 0x12ff: 0x0033,
+ // Block 0x4c, offset 0x1300
+ 0x1300: 0x0233, 0x1301: 0x0236, 0x1302: 0x0242, 0x1303: 0x024b, 0x1305: 0x0284,
+ 0x1306: 0x0254, 0x1307: 0x0245, 0x1308: 0x0263, 0x1309: 0x028a, 0x130a: 0x0275, 0x130b: 0x0278,
+ 0x130c: 0x027b, 0x130d: 0x027e, 0x130e: 0x0257, 0x130f: 0x0269, 0x1310: 0x026f, 0x1311: 0x025d,
+ 0x1312: 0x0272, 0x1313: 0x0251, 0x1314: 0x025a, 0x1315: 0x023c, 0x1316: 0x023f, 0x1317: 0x0248,
+ 0x1318: 0x024e, 0x1319: 0x0260, 0x131a: 0x0266, 0x131b: 0x026c, 0x131c: 0x028d, 0x131d: 0x02de,
+ 0x131e: 0x02c6, 0x131f: 0x0290, 0x1321: 0x0236, 0x1322: 0x0242,
+ 0x1324: 0x0281, 0x1327: 0x0245, 0x1329: 0x028a,
+ 0x132a: 0x0275, 0x132b: 0x0278, 0x132c: 0x027b, 0x132d: 0x027e, 0x132e: 0x0257, 0x132f: 0x0269,
+ 0x1330: 0x026f, 0x1331: 0x025d, 0x1332: 0x0272, 0x1334: 0x025a, 0x1335: 0x023c,
+ 0x1336: 0x023f, 0x1337: 0x0248, 0x1339: 0x0260, 0x133b: 0x026c,
+ // Block 0x4d, offset 0x1340
+ 0x1342: 0x0242,
+ 0x1347: 0x0245, 0x1349: 0x028a, 0x134b: 0x0278,
+ 0x134d: 0x027e, 0x134e: 0x0257, 0x134f: 0x0269, 0x1351: 0x025d,
+ 0x1352: 0x0272, 0x1354: 0x025a, 0x1357: 0x0248,
+ 0x1359: 0x0260, 0x135b: 0x026c, 0x135d: 0x02de,
+ 0x135f: 0x0290, 0x1361: 0x0236, 0x1362: 0x0242,
+ 0x1364: 0x0281, 0x1367: 0x0245, 0x1368: 0x0263, 0x1369: 0x028a,
+ 0x136a: 0x0275, 0x136c: 0x027b, 0x136d: 0x027e, 0x136e: 0x0257, 0x136f: 0x0269,
+ 0x1370: 0x026f, 0x1371: 0x025d, 0x1372: 0x0272, 0x1374: 0x025a, 0x1375: 0x023c,
+ 0x1376: 0x023f, 0x1377: 0x0248, 0x1379: 0x0260, 0x137a: 0x0266, 0x137b: 0x026c,
+ 0x137c: 0x028d, 0x137e: 0x02c6,
+ // Block 0x4e, offset 0x1380
+ 0x1380: 0x0233, 0x1381: 0x0236, 0x1382: 0x0242, 0x1383: 0x024b, 0x1384: 0x0281, 0x1385: 0x0284,
+ 0x1386: 0x0254, 0x1387: 0x0245, 0x1388: 0x0263, 0x1389: 0x028a, 0x138b: 0x0278,
+ 0x138c: 0x027b, 0x138d: 0x027e, 0x138e: 0x0257, 0x138f: 0x0269, 0x1390: 0x026f, 0x1391: 0x025d,
+ 0x1392: 0x0272, 0x1393: 0x0251, 0x1394: 0x025a, 0x1395: 0x023c, 0x1396: 0x023f, 0x1397: 0x0248,
+ 0x1398: 0x024e, 0x1399: 0x0260, 0x139a: 0x0266, 0x139b: 0x026c,
+ 0x13a1: 0x0236, 0x13a2: 0x0242, 0x13a3: 0x024b,
+ 0x13a5: 0x0284, 0x13a6: 0x0254, 0x13a7: 0x0245, 0x13a8: 0x0263, 0x13a9: 0x028a,
+ 0x13ab: 0x0278, 0x13ac: 0x027b, 0x13ad: 0x027e, 0x13ae: 0x0257, 0x13af: 0x0269,
+ 0x13b0: 0x026f, 0x13b1: 0x025d, 0x13b2: 0x0272, 0x13b3: 0x0251, 0x13b4: 0x025a, 0x13b5: 0x023c,
+ 0x13b6: 0x023f, 0x13b7: 0x0248, 0x13b8: 0x024e, 0x13b9: 0x0260, 0x13ba: 0x0266, 0x13bb: 0x026c,
+ // Block 0x4f, offset 0x13c0
+ 0x13c0: 0x19bb, 0x13c1: 0x19b8, 0x13c2: 0x19be, 0x13c3: 0x19e2, 0x13c4: 0x1a06, 0x13c5: 0x1a2a,
+ 0x13c6: 0x1a4e, 0x13c7: 0x1a57, 0x13c8: 0x1a5d, 0x13c9: 0x1a63, 0x13ca: 0x1a69,
+ 0x13d0: 0x1bce, 0x13d1: 0x1bd2,
+ 0x13d2: 0x1bd6, 0x13d3: 0x1bda, 0x13d4: 0x1bde, 0x13d5: 0x1be2, 0x13d6: 0x1be6, 0x13d7: 0x1bea,
+ 0x13d8: 0x1bee, 0x13d9: 0x1bf2, 0x13da: 0x1bf6, 0x13db: 0x1bfa, 0x13dc: 0x1bfe, 0x13dd: 0x1c02,
+ 0x13de: 0x1c06, 0x13df: 0x1c0a, 0x13e0: 0x1c0e, 0x13e1: 0x1c12, 0x13e2: 0x1c16, 0x13e3: 0x1c1a,
+ 0x13e4: 0x1c1e, 0x13e5: 0x1c22, 0x13e6: 0x1c26, 0x13e7: 0x1c2a, 0x13e8: 0x1c2e, 0x13e9: 0x1c32,
+ 0x13ea: 0x28c9, 0x13eb: 0x0047, 0x13ec: 0x0065, 0x13ed: 0x1a7e, 0x13ee: 0x1af3,
+ 0x13f0: 0x0043, 0x13f1: 0x0045, 0x13f2: 0x0047, 0x13f3: 0x0049, 0x13f4: 0x004b, 0x13f5: 0x004d,
+ 0x13f6: 0x004f, 0x13f7: 0x0051, 0x13f8: 0x0053, 0x13f9: 0x0055, 0x13fa: 0x0057, 0x13fb: 0x0059,
+ 0x13fc: 0x005b, 0x13fd: 0x005d, 0x13fe: 0x005f, 0x13ff: 0x0061,
+ // Block 0x50, offset 0x1400
+ 0x1400: 0x2858, 0x1401: 0x286d, 0x1402: 0x0575,
+ 0x1410: 0x0c81, 0x1411: 0x0ab9,
+ 0x1412: 0x0945, 0x1413: 0x45aa, 0x1414: 0x078d, 0x1415: 0x0a61, 0x1416: 0x13a1, 0x1417: 0x0a71,
+ 0x1418: 0x0799, 0x1419: 0x0d49, 0x141a: 0x0f21, 0x141b: 0x0d21, 0x141c: 0x0899, 0x141d: 0x0bdd,
+ 0x141e: 0x0831, 0x141f: 0x0d29, 0x1420: 0x0885, 0x1421: 0x1189, 0x1422: 0x0ff5, 0x1423: 0x13fd,
+ 0x1424: 0x0a45, 0x1425: 0x097d, 0x1426: 0x0ed5, 0x1427: 0x0c8d, 0x1428: 0x0cb9, 0x1429: 0x0731,
+ 0x142a: 0x073d, 0x142b: 0x147d, 0x142c: 0x0b4d, 0x142d: 0x0759, 0x142e: 0x0961, 0x142f: 0x0cad,
+ 0x1430: 0x1425, 0x1431: 0x0c85, 0x1432: 0x10e1, 0x1433: 0x111d, 0x1434: 0x0969, 0x1435: 0x0eb5,
+ 0x1436: 0x0d7d, 0x1437: 0x0d79, 0x1438: 0x1009, 0x1439: 0x089d, 0x143a: 0x09c9,
+ // Block 0x51, offset 0x1440
+ 0x1440: 0x076d, 0x1441: 0x0765, 0x1442: 0x0775, 0x1443: 0x16a9, 0x1444: 0x07b9, 0x1445: 0x07c9,
+ 0x1446: 0x07cd, 0x1447: 0x07d5, 0x1448: 0x07dd, 0x1449: 0x07e1, 0x144a: 0x07ed, 0x144b: 0x07e5,
+ 0x144c: 0x0625, 0x144d: 0x16bd, 0x144e: 0x0801, 0x144f: 0x0805, 0x1450: 0x0809, 0x1451: 0x0825,
+ 0x1452: 0x16ae, 0x1453: 0x0629, 0x1454: 0x0811, 0x1455: 0x0831, 0x1456: 0x16b8, 0x1457: 0x0841,
+ 0x1458: 0x0849, 0x1459: 0x07a9, 0x145a: 0x0851, 0x145b: 0x0855, 0x145c: 0x1893, 0x145d: 0x0871,
+ 0x145e: 0x0879, 0x145f: 0x0631, 0x1460: 0x0891, 0x1461: 0x0895, 0x1462: 0x089d, 0x1463: 0x08a1,
+ 0x1464: 0x0635, 0x1465: 0x08b9, 0x1466: 0x08bd, 0x1467: 0x08c9, 0x1468: 0x08d5, 0x1469: 0x08d9,
+ 0x146a: 0x08dd, 0x146b: 0x08e5, 0x146c: 0x0905, 0x146d: 0x0909, 0x146e: 0x0911, 0x146f: 0x0921,
+ 0x1470: 0x0929, 0x1471: 0x092d, 0x1472: 0x092d, 0x1473: 0x092d, 0x1474: 0x16cc, 0x1475: 0x0f05,
+ 0x1476: 0x0941, 0x1477: 0x0949, 0x1478: 0x16d1, 0x1479: 0x0955, 0x147a: 0x095d, 0x147b: 0x0965,
+ 0x147c: 0x098d, 0x147d: 0x0979, 0x147e: 0x0985, 0x147f: 0x0989,
+ // Block 0x52, offset 0x1480
+ 0x1480: 0x0991, 0x1481: 0x0999, 0x1482: 0x099d, 0x1483: 0x09a5, 0x1484: 0x09ad, 0x1485: 0x09b1,
+ 0x1486: 0x09b1, 0x1487: 0x09b9, 0x1488: 0x09c1, 0x1489: 0x09c5, 0x148a: 0x09d1, 0x148b: 0x09f5,
+ 0x148c: 0x09d9, 0x148d: 0x09f9, 0x148e: 0x09dd, 0x148f: 0x09e5, 0x1490: 0x087d, 0x1491: 0x0a41,
+ 0x1492: 0x0a09, 0x1493: 0x0a0d, 0x1494: 0x0a11, 0x1495: 0x0a05, 0x1496: 0x0a19, 0x1497: 0x0a15,
+ 0x1498: 0x0a2d, 0x1499: 0x16d6, 0x149a: 0x0a49, 0x149b: 0x0a4d, 0x149c: 0x0a55, 0x149d: 0x0a61,
+ 0x149e: 0x0a69, 0x149f: 0x0a85, 0x14a0: 0x16db, 0x14a1: 0x16e0, 0x14a2: 0x0a91, 0x14a3: 0x0a95,
+ 0x14a4: 0x0a99, 0x14a5: 0x0a8d, 0x14a6: 0x0aa1, 0x14a7: 0x0639, 0x14a8: 0x063d, 0x14a9: 0x0aa9,
+ 0x14aa: 0x0ab1, 0x14ab: 0x0ab1, 0x14ac: 0x16e5, 0x14ad: 0x0acd, 0x14ae: 0x0ad1, 0x14af: 0x0ad5,
+ 0x14b0: 0x0add, 0x14b1: 0x16ea, 0x14b2: 0x0ae5, 0x14b3: 0x0ae9, 0x14b4: 0x0bc1, 0x14b5: 0x0af1,
+ 0x14b6: 0x0641, 0x14b7: 0x0afd, 0x14b8: 0x0b0d, 0x14b9: 0x0b19, 0x14ba: 0x0b15, 0x14bb: 0x16f4,
+ 0x14bc: 0x0b21, 0x14bd: 0x16f9, 0x14be: 0x0b2d, 0x14bf: 0x0b29,
+ // Block 0x53, offset 0x14c0
+ 0x14c0: 0x0b31, 0x14c1: 0x0b41, 0x14c2: 0x0b45, 0x14c3: 0x0645, 0x14c4: 0x0b55, 0x14c5: 0x0b5d,
+ 0x14c6: 0x0b61, 0x14c7: 0x0b65, 0x14c8: 0x0649, 0x14c9: 0x16fe, 0x14ca: 0x064d, 0x14cb: 0x0b81,
+ 0x14cc: 0x0b85, 0x14cd: 0x0b89, 0x14ce: 0x0b91, 0x14cf: 0x18c5, 0x14d0: 0x0ba9, 0x14d1: 0x1708,
+ 0x14d2: 0x1708, 0x14d3: 0x1249, 0x14d4: 0x0bb9, 0x14d5: 0x0bb9, 0x14d6: 0x0651, 0x14d7: 0x172b,
+ 0x14d8: 0x17fd, 0x14d9: 0x0bc9, 0x14da: 0x0bd1, 0x14db: 0x0655, 0x14dc: 0x0be5, 0x14dd: 0x0bf5,
+ 0x14de: 0x0bf9, 0x14df: 0x0c01, 0x14e0: 0x0c11, 0x14e1: 0x065d, 0x14e2: 0x0659, 0x14e3: 0x0c15,
+ 0x14e4: 0x170d, 0x14e5: 0x0c19, 0x14e6: 0x0c2d, 0x14e7: 0x0c31, 0x14e8: 0x0c35, 0x14e9: 0x0c31,
+ 0x14ea: 0x0c41, 0x14eb: 0x0c45, 0x14ec: 0x0c55, 0x14ed: 0x0c4d, 0x14ee: 0x0c51, 0x14ef: 0x0c59,
+ 0x14f0: 0x0c5d, 0x14f1: 0x0c61, 0x14f2: 0x0c6d, 0x14f3: 0x0c71, 0x14f4: 0x0c89, 0x14f5: 0x0c91,
+ 0x14f6: 0x0ca1, 0x14f7: 0x0cb5, 0x14f8: 0x171c, 0x14f9: 0x0cb1, 0x14fa: 0x0ca5, 0x14fb: 0x0cbd,
+ 0x14fc: 0x0cc5, 0x14fd: 0x0cd9, 0x14fe: 0x1721, 0x14ff: 0x0ce1,
+ // Block 0x54, offset 0x1500
+ 0x1500: 0x0cd5, 0x1501: 0x0ccd, 0x1502: 0x0661, 0x1503: 0x0ce9, 0x1504: 0x0cf1, 0x1505: 0x0cf9,
+ 0x1506: 0x0ced, 0x1507: 0x0665, 0x1508: 0x0d09, 0x1509: 0x0d11, 0x150a: 0x1726, 0x150b: 0x0d3d,
+ 0x150c: 0x0d71, 0x150d: 0x0d4d, 0x150e: 0x0671, 0x150f: 0x0d59, 0x1510: 0x066d, 0x1511: 0x0669,
+ 0x1512: 0x0835, 0x1513: 0x0839, 0x1514: 0x0d75, 0x1515: 0x0d5d, 0x1516: 0x121d, 0x1517: 0x06d5,
+ 0x1518: 0x0d81, 0x1519: 0x0d85, 0x151a: 0x0d89, 0x151b: 0x0d9d, 0x151c: 0x0d95, 0x151d: 0x173f,
+ 0x151e: 0x0675, 0x151f: 0x0db1, 0x1520: 0x0da5, 0x1521: 0x0dc1, 0x1522: 0x0dc9, 0x1523: 0x1749,
+ 0x1524: 0x0dcd, 0x1525: 0x0db9, 0x1526: 0x0dd5, 0x1527: 0x0679, 0x1528: 0x0dd9, 0x1529: 0x0ddd,
+ 0x152a: 0x0de1, 0x152b: 0x0ded, 0x152c: 0x174e, 0x152d: 0x0df5, 0x152e: 0x067d, 0x152f: 0x0e01,
+ 0x1530: 0x1753, 0x1531: 0x0e05, 0x1532: 0x0681, 0x1533: 0x0e11, 0x1534: 0x0e1d, 0x1535: 0x0e29,
+ 0x1536: 0x0e2d, 0x1537: 0x1758, 0x1538: 0x16ef, 0x1539: 0x175d, 0x153a: 0x0e4d, 0x153b: 0x1762,
+ 0x153c: 0x0e59, 0x153d: 0x0e61, 0x153e: 0x0e51, 0x153f: 0x0e6d,
+ // Block 0x55, offset 0x1540
+ 0x1540: 0x0e7d, 0x1541: 0x0e8d, 0x1542: 0x0e81, 0x1543: 0x0e85, 0x1544: 0x0e91, 0x1545: 0x0e95,
+ 0x1546: 0x1767, 0x1547: 0x0e79, 0x1548: 0x0ead, 0x1549: 0x0eb1, 0x154a: 0x0685, 0x154b: 0x0ec5,
+ 0x154c: 0x0ec1, 0x154d: 0x176c, 0x154e: 0x0ea5, 0x154f: 0x0ee1, 0x1550: 0x1771, 0x1551: 0x1776,
+ 0x1552: 0x0ee5, 0x1553: 0x0ef9, 0x1554: 0x0ef5, 0x1555: 0x0ef1, 0x1556: 0x0689, 0x1557: 0x0efd,
+ 0x1558: 0x0f0d, 0x1559: 0x0f09, 0x155a: 0x0f15, 0x155b: 0x16b3, 0x155c: 0x0f25, 0x155d: 0x177b,
+ 0x155e: 0x0f31, 0x155f: 0x1785, 0x1560: 0x0f45, 0x1561: 0x0f51, 0x1562: 0x0f65, 0x1563: 0x178a,
+ 0x1564: 0x0f79, 0x1565: 0x0f7d, 0x1566: 0x178f, 0x1567: 0x1794, 0x1568: 0x0f99, 0x1569: 0x0fa9,
+ 0x156a: 0x068d, 0x156b: 0x0fad, 0x156c: 0x0691, 0x156d: 0x0691, 0x156e: 0x0fc5, 0x156f: 0x0fc9,
+ 0x1570: 0x0fd1, 0x1571: 0x0fd5, 0x1572: 0x0fe1, 0x1573: 0x0695, 0x1574: 0x0ff9, 0x1575: 0x1799,
+ 0x1576: 0x1015, 0x1577: 0x179e, 0x1578: 0x1021, 0x1579: 0x1703, 0x157a: 0x1031, 0x157b: 0x17a3,
+ 0x157c: 0x17a8, 0x157d: 0x17ad, 0x157e: 0x0699, 0x157f: 0x069d,
+ // Block 0x56, offset 0x1580
+ 0x1580: 0x1069, 0x1581: 0x17b7, 0x1582: 0x17b2, 0x1583: 0x17bc, 0x1584: 0x17c1, 0x1585: 0x1071,
+ 0x1586: 0x1075, 0x1587: 0x1075, 0x1588: 0x107d, 0x1589: 0x06a5, 0x158a: 0x1081, 0x158b: 0x06a9,
+ 0x158c: 0x06ad, 0x158d: 0x17cb, 0x158e: 0x1095, 0x158f: 0x109d, 0x1590: 0x10a9, 0x1591: 0x06b1,
+ 0x1592: 0x17d0, 0x1593: 0x10cd, 0x1594: 0x17d5, 0x1595: 0x17da, 0x1596: 0x10ed, 0x1597: 0x1105,
+ 0x1598: 0x06b5, 0x1599: 0x110d, 0x159a: 0x1111, 0x159b: 0x1115, 0x159c: 0x17df, 0x159d: 0x17e4,
+ 0x159e: 0x17e4, 0x159f: 0x112d, 0x15a0: 0x06b9, 0x15a1: 0x17e9, 0x15a2: 0x1141, 0x15a3: 0x1145,
+ 0x15a4: 0x06bd, 0x15a5: 0x17ee, 0x15a6: 0x1161, 0x15a7: 0x06c1, 0x15a8: 0x1171, 0x15a9: 0x1169,
+ 0x15aa: 0x1179, 0x15ab: 0x17f8, 0x15ac: 0x1191, 0x15ad: 0x06c5, 0x15ae: 0x119d, 0x15af: 0x11a5,
+ 0x15b0: 0x11b5, 0x15b1: 0x06c9, 0x15b2: 0x1802, 0x15b3: 0x1807, 0x15b4: 0x06cd, 0x15b5: 0x180c,
+ 0x15b6: 0x11cd, 0x15b7: 0x1811, 0x15b8: 0x11d9, 0x15b9: 0x11e5, 0x15ba: 0x11ed, 0x15bb: 0x1816,
+ 0x15bc: 0x181b, 0x15bd: 0x1201, 0x15be: 0x1820, 0x15bf: 0x1209,
+ // Block 0x57, offset 0x15c0
+ 0x15c0: 0x1730, 0x15c1: 0x06d1, 0x15c2: 0x1221, 0x15c3: 0x1225, 0x15c4: 0x06d9, 0x15c5: 0x1229,
+ 0x15c6: 0x0aa5, 0x15c7: 0x1825, 0x15c8: 0x182a, 0x15c9: 0x1735, 0x15ca: 0x173a, 0x15cb: 0x1249,
+ 0x15cc: 0x124d, 0x15cd: 0x1465, 0x15ce: 0x06dd, 0x15cf: 0x1279, 0x15d0: 0x1275, 0x15d1: 0x127d,
+ 0x15d2: 0x08b1, 0x15d3: 0x1281, 0x15d4: 0x1285, 0x15d5: 0x1289, 0x15d6: 0x1291, 0x15d7: 0x182f,
+ 0x15d8: 0x128d, 0x15d9: 0x1295, 0x15da: 0x12a9, 0x15db: 0x12ad, 0x15dc: 0x1299, 0x15dd: 0x12b1,
+ 0x15de: 0x12c5, 0x15df: 0x12d9, 0x15e0: 0x12a5, 0x15e1: 0x12b9, 0x15e2: 0x12bd, 0x15e3: 0x12c1,
+ 0x15e4: 0x1834, 0x15e5: 0x183e, 0x15e6: 0x1839, 0x15e7: 0x06e1, 0x15e8: 0x12e1, 0x15e9: 0x12e5,
+ 0x15ea: 0x12ed, 0x15eb: 0x1852, 0x15ec: 0x12f1, 0x15ed: 0x1843, 0x15ee: 0x06e5, 0x15ef: 0x06e9,
+ 0x15f0: 0x1848, 0x15f1: 0x184d, 0x15f2: 0x06ed, 0x15f3: 0x1311, 0x15f4: 0x1315, 0x15f5: 0x1319,
+ 0x15f6: 0x131d, 0x15f7: 0x1329, 0x15f8: 0x1325, 0x15f9: 0x1331, 0x15fa: 0x132d, 0x15fb: 0x133d,
+ 0x15fc: 0x1335, 0x15fd: 0x1339, 0x15fe: 0x1341, 0x15ff: 0x06f1,
+ // Block 0x58, offset 0x1600
+ 0x1600: 0x1349, 0x1601: 0x134d, 0x1602: 0x06f5, 0x1603: 0x135d, 0x1604: 0x1361, 0x1605: 0x1857,
+ 0x1606: 0x136d, 0x1607: 0x1371, 0x1608: 0x06f9, 0x1609: 0x137d, 0x160a: 0x062d, 0x160b: 0x185c,
+ 0x160c: 0x1861, 0x160d: 0x06fd, 0x160e: 0x0701, 0x160f: 0x13a9, 0x1610: 0x13c1, 0x1611: 0x13dd,
+ 0x1612: 0x13ed, 0x1613: 0x1866, 0x1614: 0x1401, 0x1615: 0x1405, 0x1616: 0x141d, 0x1617: 0x1429,
+ 0x1618: 0x1870, 0x1619: 0x16c2, 0x161a: 0x1435, 0x161b: 0x1431, 0x161c: 0x143d, 0x161d: 0x16c7,
+ 0x161e: 0x1449, 0x161f: 0x1455, 0x1620: 0x1875, 0x1621: 0x187a, 0x1622: 0x1495, 0x1623: 0x14a1,
+ 0x1624: 0x14a9, 0x1625: 0x187f, 0x1626: 0x14ad, 0x1627: 0x14d5, 0x1628: 0x14e1, 0x1629: 0x14e5,
+ 0x162a: 0x14dd, 0x162b: 0x14f1, 0x162c: 0x14f5, 0x162d: 0x1884, 0x162e: 0x1501, 0x162f: 0x0705,
+ 0x1630: 0x1509, 0x1631: 0x1889, 0x1632: 0x0709, 0x1633: 0x1541, 0x1634: 0x0b35, 0x1635: 0x1559,
+ 0x1636: 0x188e, 0x1637: 0x1898, 0x1638: 0x070d, 0x1639: 0x0711, 0x163a: 0x1581, 0x163b: 0x189d,
+ 0x163c: 0x0715, 0x163d: 0x18a2, 0x163e: 0x1599, 0x163f: 0x1599,
+ // Block 0x59, offset 0x1640
+ 0x1640: 0x15a1, 0x1641: 0x18a7, 0x1642: 0x15b9, 0x1643: 0x0719, 0x1644: 0x15c9, 0x1645: 0x15d5,
+ 0x1646: 0x15dd, 0x1647: 0x15e5, 0x1648: 0x071d, 0x1649: 0x18ac, 0x164a: 0x15f9, 0x164b: 0x1615,
+ 0x164c: 0x1621, 0x164d: 0x0721, 0x164e: 0x0725, 0x164f: 0x1625, 0x1650: 0x18b1, 0x1651: 0x0729,
+ 0x1652: 0x18b6, 0x1653: 0x18bb, 0x1654: 0x18c0, 0x1655: 0x1649, 0x1656: 0x072d, 0x1657: 0x165d,
+ 0x1658: 0x1665, 0x1659: 0x1669, 0x165a: 0x1671, 0x165b: 0x1679, 0x165c: 0x1681, 0x165d: 0x18ca,
+}
+
+// nfkcSparseOffset: 128 entries, 256 bytes
+var nfkcSparseOffset = []uint16{0x0, 0xe, 0x12, 0x1b, 0x25, 0x35, 0x37, 0x3c, 0x47, 0x56, 0x63, 0x6b, 0x6f, 0x74, 0x76, 0x85, 0x8d, 0x94, 0x97, 0x9f, 0xa3, 0xa7, 0xa9, 0xab, 0xb4, 0xb8, 0xbf, 0xc4, 0xc7, 0xd1, 0xd3, 0xda, 0xe2, 0xe6, 0xe8, 0xeb, 0xef, 0xf5, 0x106, 0x112, 0x114, 0x11a, 0x11c, 0x11e, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12b, 0x12e, 0x130, 0x133, 0x136, 0x13a, 0x143, 0x145, 0x148, 0x14a, 0x154, 0x15f, 0x16e, 0x17c, 0x18a, 0x19a, 0x1a8, 0x1af, 0x1b5, 0x1c4, 0x1c8, 0x1ca, 0x1ce, 0x1d0, 0x1d3, 0x1d5, 0x1d8, 0x1da, 0x1dd, 0x1df, 0x1e1, 0x1e3, 0x1ef, 0x1f8, 0x1ff, 0x20c, 0x20f, 0x211, 0x213, 0x215, 0x217, 0x219, 0x21c, 0x21e, 0x220, 0x222, 0x224, 0x22a, 0x22d, 0x22f, 0x231, 0x233, 0x235, 0x244, 0x246, 0x24c, 0x254, 0x25b, 0x25e, 0x26b, 0x275, 0x277, 0x279, 0x27d, 0x282, 0x28e, 0x293, 0x29c, 0x2a2, 0x2a7, 0x2ab, 0x2b0, 0x2b4, 0x2c4, 0x2d2, 0x2e0, 0x2ee, 0x2f8, 0x2fa}
+
+// nfkcSparseValues: 772 entries, 3088 bytes
+var nfkcSparseValues = [772]valueRange{
+ // Block 0x0, offset 0x1
+ {value: 0x0002, lo: 0x0d},
+ {value: 0x0001, lo: 0xa0, hi: 0xa0},
+ {value: 0x425e, lo: 0xa8, hi: 0xa8},
+ {value: 0x0083, lo: 0xaa, hi: 0xaa},
+ {value: 0x424a, lo: 0xaf, hi: 0xaf},
+ {value: 0x0025, lo: 0xb2, hi: 0xb3},
+ {value: 0x4240, lo: 0xb4, hi: 0xb4},
+ {value: 0x01dc, lo: 0xb5, hi: 0xb5},
+ {value: 0x4277, lo: 0xb8, hi: 0xb8},
+ {value: 0x0023, lo: 0xb9, hi: 0xb9},
+ {value: 0x009f, lo: 0xba, hi: 0xba},
+ {value: 0x235e, lo: 0xbc, hi: 0xbc},
+ {value: 0x2352, lo: 0xbd, hi: 0xbd},
+ {value: 0x23f4, lo: 0xbe, hi: 0xbe},
+ // Block 0x1, offset 0x2
+ {value: 0x0091, lo: 0x03},
+ {value: 0x46c8, lo: 0xa0, hi: 0xa1},
+ {value: 0x46fa, lo: 0xaf, hi: 0xb0},
+ {value: 0x8800, lo: 0xb7, hi: 0xb7},
+ // Block 0x2, offset 0x3
+ {value: 0x0003, lo: 0x08},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x0091, lo: 0xb0, hi: 0xb0},
+ {value: 0x011c, lo: 0xb1, hi: 0xb1},
+ {value: 0x0095, lo: 0xb2, hi: 0xb2},
+ {value: 0x00a5, lo: 0xb3, hi: 0xb3},
+ {value: 0x0143, lo: 0xb4, hi: 0xb6},
+ {value: 0x00af, lo: 0xb7, hi: 0xb7},
+ {value: 0x00b3, lo: 0xb8, hi: 0xb8},
+ // Block 0x3, offset 0x4
+ {value: 0x000a, lo: 0x09},
+ {value: 0x4254, lo: 0x98, hi: 0x98},
+ {value: 0x4259, lo: 0x99, hi: 0x9a},
+ {value: 0x427c, lo: 0x9b, hi: 0x9b},
+ {value: 0x4245, lo: 0x9c, hi: 0x9c},
+ {value: 0x4268, lo: 0x9d, hi: 0x9d},
+ {value: 0x0116, lo: 0xa0, hi: 0xa0},
+ {value: 0x0099, lo: 0xa1, hi: 0xa1},
+ {value: 0x00a7, lo: 0xa2, hi: 0xa3},
+ {value: 0x0167, lo: 0xa4, hi: 0xa4},
+ // Block 0x4, offset 0x5
+ {value: 0x0000, lo: 0x0f},
+ {value: 0x8800, lo: 0x83, hi: 0x83},
+ {value: 0x8800, lo: 0x87, hi: 0x87},
+ {value: 0x8800, lo: 0x8b, hi: 0x8b},
+ {value: 0x8800, lo: 0x8d, hi: 0x8d},
+ {value: 0x378f, lo: 0x90, hi: 0x90},
+ {value: 0x379b, lo: 0x91, hi: 0x91},
+ {value: 0x3789, lo: 0x93, hi: 0x93},
+ {value: 0x8800, lo: 0x96, hi: 0x96},
+ {value: 0x3801, lo: 0x97, hi: 0x97},
+ {value: 0x37cb, lo: 0x9c, hi: 0x9c},
+ {value: 0x37b3, lo: 0x9d, hi: 0x9d},
+ {value: 0x37dd, lo: 0x9e, hi: 0x9e},
+ {value: 0x8800, lo: 0xb4, hi: 0xb5},
+ {value: 0x3807, lo: 0xb6, hi: 0xb6},
+ {value: 0x380d, lo: 0xb7, hi: 0xb7},
+ // Block 0x5, offset 0x6
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x83, hi: 0x87},
+ // Block 0x6, offset 0x7
+ {value: 0x0001, lo: 0x04},
+ {value: 0x8018, lo: 0x81, hi: 0x82},
+ {value: 0x80e6, lo: 0x84, hi: 0x84},
+ {value: 0x80dc, lo: 0x85, hi: 0x85},
+ {value: 0x8012, lo: 0x87, hi: 0x87},
+ // Block 0x7, offset 0x8
+ {value: 0x0000, lo: 0x0a},
+ {value: 0x80e6, lo: 0x90, hi: 0x97},
+ {value: 0x801e, lo: 0x98, hi: 0x98},
+ {value: 0x801f, lo: 0x99, hi: 0x99},
+ {value: 0x8020, lo: 0x9a, hi: 0x9a},
+ {value: 0x382b, lo: 0xa2, hi: 0xa2},
+ {value: 0x3831, lo: 0xa3, hi: 0xa3},
+ {value: 0x383d, lo: 0xa4, hi: 0xa4},
+ {value: 0x3837, lo: 0xa5, hi: 0xa5},
+ {value: 0x3843, lo: 0xa6, hi: 0xa6},
+ {value: 0x8800, lo: 0xa7, hi: 0xa7},
+ // Block 0x8, offset 0x9
+ {value: 0x0000, lo: 0x0e},
+ {value: 0x3855, lo: 0x80, hi: 0x80},
+ {value: 0x8800, lo: 0x81, hi: 0x81},
+ {value: 0x3849, lo: 0x82, hi: 0x82},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x384f, lo: 0x93, hi: 0x93},
+ {value: 0x8800, lo: 0x95, hi: 0x95},
+ {value: 0x80e6, lo: 0x96, hi: 0x9c},
+ {value: 0x80e6, lo: 0x9f, hi: 0xa2},
+ {value: 0x80dc, lo: 0xa3, hi: 0xa3},
+ {value: 0x80e6, lo: 0xa4, hi: 0xa4},
+ {value: 0x80e6, lo: 0xa7, hi: 0xa8},
+ {value: 0x80dc, lo: 0xaa, hi: 0xaa},
+ {value: 0x80e6, lo: 0xab, hi: 0xac},
+ {value: 0x80dc, lo: 0xad, hi: 0xad},
+ // Block 0x9, offset 0xa
+ {value: 0x0000, lo: 0x0c},
+ {value: 0x8024, lo: 0x91, hi: 0x91},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb0},
+ {value: 0x80dc, lo: 0xb1, hi: 0xb1},
+ {value: 0x80e6, lo: 0xb2, hi: 0xb3},
+ {value: 0x80dc, lo: 0xb4, hi: 0xb4},
+ {value: 0x80e6, lo: 0xb5, hi: 0xb6},
+ {value: 0x80dc, lo: 0xb7, hi: 0xb9},
+ {value: 0x80e6, lo: 0xba, hi: 0xba},
+ {value: 0x80dc, lo: 0xbb, hi: 0xbc},
+ {value: 0x80e6, lo: 0xbd, hi: 0xbd},
+ {value: 0x80dc, lo: 0xbe, hi: 0xbe},
+ {value: 0x80e6, lo: 0xbf, hi: 0xbf},
+ // Block 0xa, offset 0xb
+ {value: 0x000a, lo: 0x07},
+ {value: 0x80e6, lo: 0x80, hi: 0x80},
+ {value: 0x80e6, lo: 0x81, hi: 0x81},
+ {value: 0x80dc, lo: 0x82, hi: 0x83},
+ {value: 0x80dc, lo: 0x84, hi: 0x85},
+ {value: 0x80dc, lo: 0x86, hi: 0x87},
+ {value: 0x80dc, lo: 0x88, hi: 0x89},
+ {value: 0x80e6, lo: 0x8a, hi: 0x8a},
+ // Block 0xb, offset 0xc
+ {value: 0x0000, lo: 0x03},
+ {value: 0x80e6, lo: 0xab, hi: 0xb1},
+ {value: 0x80dc, lo: 0xb2, hi: 0xb2},
+ {value: 0x80e6, lo: 0xb3, hi: 0xb3},
+ // Block 0xc, offset 0xd
+ {value: 0x0000, lo: 0x04},
+ {value: 0x80e6, lo: 0x96, hi: 0x99},
+ {value: 0x80e6, lo: 0x9b, hi: 0xa3},
+ {value: 0x80e6, lo: 0xa5, hi: 0xa7},
+ {value: 0x80e6, lo: 0xa9, hi: 0xad},
+ // Block 0xd, offset 0xe
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0x99, hi: 0x9b},
+ // Block 0xe, offset 0xf
+ {value: 0x0000, lo: 0x0e},
+ {value: 0x80e6, lo: 0xa4, hi: 0xa5},
+ {value: 0x80dc, lo: 0xa6, hi: 0xa6},
+ {value: 0x80e6, lo: 0xa7, hi: 0xa8},
+ {value: 0x80dc, lo: 0xa9, hi: 0xa9},
+ {value: 0x80e6, lo: 0xaa, hi: 0xac},
+ {value: 0x80dc, lo: 0xad, hi: 0xaf},
+ {value: 0x801b, lo: 0xb0, hi: 0xb0},
+ {value: 0x801c, lo: 0xb1, hi: 0xb1},
+ {value: 0x801d, lo: 0xb2, hi: 0xb2},
+ {value: 0x80e6, lo: 0xb3, hi: 0xb5},
+ {value: 0x80dc, lo: 0xb6, hi: 0xb6},
+ {value: 0x80e6, lo: 0xb7, hi: 0xb8},
+ {value: 0x80dc, lo: 0xb9, hi: 0xba},
+ {value: 0x80e6, lo: 0xbb, hi: 0xbe},
+ // Block 0xf, offset 0x10
+ {value: 0x0000, lo: 0x07},
+ {value: 0x8800, lo: 0xa8, hi: 0xa8},
+ {value: 0x3ec2, lo: 0xa9, hi: 0xa9},
+ {value: 0x8800, lo: 0xb0, hi: 0xb0},
+ {value: 0x3eca, lo: 0xb1, hi: 0xb1},
+ {value: 0x8800, lo: 0xb3, hi: 0xb3},
+ {value: 0x3ed2, lo: 0xb4, hi: 0xb4},
+ {value: 0x8607, lo: 0xbc, hi: 0xbc},
+ // Block 0x10, offset 0x11
+ {value: 0x0008, lo: 0x06},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x80e6, lo: 0x91, hi: 0x91},
+ {value: 0x80dc, lo: 0x92, hi: 0x92},
+ {value: 0x80e6, lo: 0x93, hi: 0x93},
+ {value: 0x80e6, lo: 0x94, hi: 0x94},
+ {value: 0x4502, lo: 0x98, hi: 0x9f},
+ // Block 0x11, offset 0x12
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ {value: 0x8600, lo: 0xbe, hi: 0xbe},
+ // Block 0x12, offset 0x13
+ {value: 0x0007, lo: 0x07},
+ {value: 0x8800, lo: 0x87, hi: 0x87},
+ {value: 0x18cf, lo: 0x8b, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x97, hi: 0x97},
+ {value: 0x4542, lo: 0x9c, hi: 0x9c},
+ {value: 0x454a, lo: 0x9d, hi: 0x9d},
+ {value: 0x4552, lo: 0x9f, hi: 0x9f},
+ // Block 0x13, offset 0x14
+ {value: 0x0000, lo: 0x03},
+ {value: 0x457a, lo: 0xb3, hi: 0xb3},
+ {value: 0x4582, lo: 0xb6, hi: 0xb6},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ // Block 0x14, offset 0x15
+ {value: 0x0008, lo: 0x03},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x455a, lo: 0x99, hi: 0x9b},
+ {value: 0x4572, lo: 0x9e, hi: 0x9e},
+ // Block 0x15, offset 0x16
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ // Block 0x16, offset 0x17
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ // Block 0x17, offset 0x18
+ {value: 0x0000, lo: 0x08},
+ {value: 0x8800, lo: 0x87, hi: 0x87},
+ {value: 0x18e4, lo: 0x88, hi: 0x88},
+ {value: 0x18dd, lo: 0x8b, hi: 0x8b},
+ {value: 0x18eb, lo: 0x8c, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x96, hi: 0x97},
+ {value: 0x458a, lo: 0x9c, hi: 0x9c},
+ {value: 0x4592, lo: 0x9d, hi: 0x9d},
+ // Block 0x18, offset 0x19
+ {value: 0x0000, lo: 0x03},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x18f2, lo: 0x94, hi: 0x94},
+ {value: 0x8600, lo: 0xbe, hi: 0xbe},
+ // Block 0x19, offset 0x1a
+ {value: 0x0000, lo: 0x06},
+ {value: 0x8800, lo: 0x86, hi: 0x87},
+ {value: 0x18f9, lo: 0x8a, hi: 0x8a},
+ {value: 0x1907, lo: 0x8b, hi: 0x8b},
+ {value: 0x1900, lo: 0x8c, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x97, hi: 0x97},
+ // Block 0x1a, offset 0x1b
+ {value: 0x0607, lo: 0x04},
+ {value: 0x8800, lo: 0x86, hi: 0x86},
+ {value: 0x3eda, lo: 0x88, hi: 0x88},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8054, lo: 0x95, hi: 0x96},
+ // Block 0x1b, offset 0x1c
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8007, lo: 0xbc, hi: 0xbc},
+ {value: 0x8800, lo: 0xbf, hi: 0xbf},
+ // Block 0x1c, offset 0x1d
+ {value: 0x0000, lo: 0x09},
+ {value: 0x190e, lo: 0x80, hi: 0x80},
+ {value: 0x8600, lo: 0x82, hi: 0x82},
+ {value: 0x8800, lo: 0x86, hi: 0x86},
+ {value: 0x1915, lo: 0x87, hi: 0x87},
+ {value: 0x191c, lo: 0x88, hi: 0x88},
+ {value: 0x2e66, lo: 0x8a, hi: 0x8a},
+ {value: 0x19a5, lo: 0x8b, hi: 0x8b},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x95, hi: 0x96},
+ // Block 0x1d, offset 0x1e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8600, lo: 0xbe, hi: 0xbe},
+ // Block 0x1e, offset 0x1f
+ {value: 0x0000, lo: 0x06},
+ {value: 0x8800, lo: 0x86, hi: 0x87},
+ {value: 0x1923, lo: 0x8a, hi: 0x8a},
+ {value: 0x1931, lo: 0x8b, hi: 0x8b},
+ {value: 0x192a, lo: 0x8c, hi: 0x8c},
+ {value: 0x8009, lo: 0x8d, hi: 0x8d},
+ {value: 0x8600, lo: 0x97, hi: 0x97},
+ // Block 0x1f, offset 0x20
+ {value: 0x0007, lo: 0x07},
+ {value: 0x8609, lo: 0x8a, hi: 0x8a},
+ {value: 0x8600, lo: 0x8f, hi: 0x8f},
+ {value: 0x8800, lo: 0x99, hi: 0x99},
+ {value: 0x3ee2, lo: 0x9a, hi: 0x9a},
+ {value: 0x2e6d, lo: 0x9c, hi: 0x9d},
+ {value: 0x1938, lo: 0x9e, hi: 0x9e},
+ {value: 0x8600, lo: 0x9f, hi: 0x9f},
+ // Block 0x20, offset 0x21
+ {value: 0x0000, lo: 0x03},
+ {value: 0x2763, lo: 0xb3, hi: 0xb3},
+ {value: 0x8067, lo: 0xb8, hi: 0xb9},
+ {value: 0x8009, lo: 0xba, hi: 0xba},
+ // Block 0x21, offset 0x22
+ {value: 0x0000, lo: 0x01},
+ {value: 0x806b, lo: 0x88, hi: 0x8b},
+ // Block 0x22, offset 0x23
+ {value: 0x0000, lo: 0x02},
+ {value: 0x2778, lo: 0xb3, hi: 0xb3},
+ {value: 0x8076, lo: 0xb8, hi: 0xb9},
+ // Block 0x23, offset 0x24
+ {value: 0x0000, lo: 0x03},
+ {value: 0x807a, lo: 0x88, hi: 0x8b},
+ {value: 0x276a, lo: 0x9c, hi: 0x9c},
+ {value: 0x2771, lo: 0x9d, hi: 0x9d},
+ // Block 0x24, offset 0x25
+ {value: 0x0000, lo: 0x05},
+ {value: 0x0305, lo: 0x8c, hi: 0x8c},
+ {value: 0x80dc, lo: 0x98, hi: 0x99},
+ {value: 0x80dc, lo: 0xb5, hi: 0xb5},
+ {value: 0x80dc, lo: 0xb7, hi: 0xb7},
+ {value: 0x80d8, lo: 0xb9, hi: 0xb9},
+ // Block 0x25, offset 0x26
+ {value: 0x0000, lo: 0x10},
+ {value: 0x2786, lo: 0x83, hi: 0x83},
+ {value: 0x278d, lo: 0x8d, hi: 0x8d},
+ {value: 0x2794, lo: 0x92, hi: 0x92},
+ {value: 0x279b, lo: 0x97, hi: 0x97},
+ {value: 0x27a2, lo: 0x9c, hi: 0x9c},
+ {value: 0x277f, lo: 0xa9, hi: 0xa9},
+ {value: 0x8081, lo: 0xb1, hi: 0xb1},
+ {value: 0x8082, lo: 0xb2, hi: 0xb2},
+ {value: 0x49b6, lo: 0xb3, hi: 0xb3},
+ {value: 0x8084, lo: 0xb4, hi: 0xb4},
+ {value: 0x49bf, lo: 0xb5, hi: 0xb5},
+ {value: 0x459a, lo: 0xb6, hi: 0xb6},
+ {value: 0x45da, lo: 0xb7, hi: 0xb7},
+ {value: 0x45a2, lo: 0xb8, hi: 0xb8},
+ {value: 0x45e5, lo: 0xb9, hi: 0xb9},
+ {value: 0x8082, lo: 0xba, hi: 0xbd},
+ // Block 0x26, offset 0x27
+ {value: 0x0000, lo: 0x0b},
+ {value: 0x8082, lo: 0x80, hi: 0x80},
+ {value: 0x49c8, lo: 0x81, hi: 0x81},
+ {value: 0x80e6, lo: 0x82, hi: 0x83},
+ {value: 0x8009, lo: 0x84, hi: 0x84},
+ {value: 0x80e6, lo: 0x86, hi: 0x87},
+ {value: 0x27b0, lo: 0x93, hi: 0x93},
+ {value: 0x27b7, lo: 0x9d, hi: 0x9d},
+ {value: 0x27be, lo: 0xa2, hi: 0xa2},
+ {value: 0x27c5, lo: 0xa7, hi: 0xa7},
+ {value: 0x27cc, lo: 0xac, hi: 0xac},
+ {value: 0x27a9, lo: 0xb9, hi: 0xb9},
+ // Block 0x27, offset 0x28
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0x86, hi: 0x86},
+ // Block 0x28, offset 0x29
+ {value: 0x0000, lo: 0x05},
+ {value: 0x8800, lo: 0xa5, hi: 0xa5},
+ {value: 0x193f, lo: 0xa6, hi: 0xa6},
+ {value: 0x8600, lo: 0xae, hi: 0xae},
+ {value: 0x8007, lo: 0xb7, hi: 0xb7},
+ {value: 0x8009, lo: 0xb9, hi: 0xba},
+ // Block 0x29, offset 0x2a
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0x8d, hi: 0x8d},
+ // Block 0x2a, offset 0x2b
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0309, lo: 0xbc, hi: 0xbc},
+ // Block 0x2b, offset 0x2c
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8800, lo: 0x80, hi: 0x92},
+ // Block 0x2c, offset 0x2d
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8e00, lo: 0xa1, hi: 0xb5},
+ // Block 0x2d, offset 0x2e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8600, lo: 0xa8, hi: 0xbf},
+ // Block 0x2e, offset 0x2f
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8600, lo: 0x80, hi: 0x82},
+ // Block 0x2f, offset 0x30
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x9d, hi: 0x9f},
+ // Block 0x30, offset 0x31
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0x94, hi: 0x94},
+ {value: 0x8009, lo: 0xb4, hi: 0xb4},
+ // Block 0x31, offset 0x32
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0x92, hi: 0x92},
+ {value: 0x80e6, lo: 0x9d, hi: 0x9d},
+ // Block 0x32, offset 0x33
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e4, lo: 0xa9, hi: 0xa9},
+ // Block 0x33, offset 0x34
+ {value: 0x0008, lo: 0x02},
+ {value: 0x80de, lo: 0xb9, hi: 0xba},
+ {value: 0x80dc, lo: 0xbb, hi: 0xbb},
+ // Block 0x34, offset 0x35
+ {value: 0x0000, lo: 0x02},
+ {value: 0x80e6, lo: 0x97, hi: 0x97},
+ {value: 0x80dc, lo: 0x98, hi: 0x98},
+ // Block 0x35, offset 0x36
+ {value: 0x0000, lo: 0x03},
+ {value: 0x8009, lo: 0xa0, hi: 0xa0},
+ {value: 0x80e6, lo: 0xb5, hi: 0xbc},
+ {value: 0x80dc, lo: 0xbf, hi: 0xbf},
+ // Block 0x36, offset 0x37
+ {value: 0x0000, lo: 0x08},
+ {value: 0x197e, lo: 0x80, hi: 0x80},
+ {value: 0x1985, lo: 0x81, hi: 0x81},
+ {value: 0x8800, lo: 0x82, hi: 0x82},
+ {value: 0x198c, lo: 0x83, hi: 0x83},
+ {value: 0x8009, lo: 0x84, hi: 0x84},
+ {value: 0x80e6, lo: 0xab, hi: 0xab},
+ {value: 0x80dc, lo: 0xac, hi: 0xac},
+ {value: 0x80e6, lo: 0xad, hi: 0xb3},
+ // Block 0x37, offset 0x38
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0xaa, hi: 0xab},
+ // Block 0x38, offset 0x39
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8007, lo: 0xa6, hi: 0xa6},
+ {value: 0x8009, lo: 0xb2, hi: 0xb3},
+ // Block 0x39, offset 0x3a
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8007, lo: 0xb7, hi: 0xb7},
+ // Block 0x3a, offset 0x3b
+ {value: 0x0000, lo: 0x09},
+ {value: 0x80e6, lo: 0x90, hi: 0x92},
+ {value: 0x8001, lo: 0x94, hi: 0x94},
+ {value: 0x80dc, lo: 0x95, hi: 0x99},
+ {value: 0x80e6, lo: 0x9a, hi: 0x9b},
+ {value: 0x80dc, lo: 0x9c, hi: 0x9f},
+ {value: 0x80e6, lo: 0xa0, hi: 0xa0},
+ {value: 0x8001, lo: 0xa2, hi: 0xa8},
+ {value: 0x80dc, lo: 0xad, hi: 0xad},
+ {value: 0x80e6, lo: 0xb4, hi: 0xb4},
+ // Block 0x3b, offset 0x3c
+ {value: 0x0002, lo: 0x0a},
+ {value: 0x0043, lo: 0xac, hi: 0xac},
+ {value: 0x00d4, lo: 0xad, hi: 0xad},
+ {value: 0x0045, lo: 0xae, hi: 0xae},
+ {value: 0x0049, lo: 0xb0, hi: 0xb1},
+ {value: 0x00e9, lo: 0xb2, hi: 0xb2},
+ {value: 0x004f, lo: 0xb3, hi: 0xba},
+ {value: 0x005f, lo: 0xbc, hi: 0xbc},
+ {value: 0x00f2, lo: 0xbd, hi: 0xbd},
+ {value: 0x0061, lo: 0xbe, hi: 0xbe},
+ {value: 0x0065, lo: 0xbf, hi: 0xbf},
+ // Block 0x3c, offset 0x3d
+ {value: 0x0000, lo: 0x0e},
+ {value: 0x80e6, lo: 0x80, hi: 0x81},
+ {value: 0x80dc, lo: 0x82, hi: 0x82},
+ {value: 0x80e6, lo: 0x83, hi: 0x89},
+ {value: 0x80dc, lo: 0x8a, hi: 0x8a},
+ {value: 0x80e6, lo: 0x8b, hi: 0x8c},
+ {value: 0x80ea, lo: 0x8d, hi: 0x8d},
+ {value: 0x80d6, lo: 0x8e, hi: 0x8e},
+ {value: 0x80dc, lo: 0x8f, hi: 0x8f},
+ {value: 0x80ca, lo: 0x90, hi: 0x90},
+ {value: 0x80e6, lo: 0x91, hi: 0xa6},
+ {value: 0x80e9, lo: 0xbc, hi: 0xbc},
+ {value: 0x80dc, lo: 0xbd, hi: 0xbd},
+ {value: 0x80e6, lo: 0xbe, hi: 0xbe},
+ {value: 0x80dc, lo: 0xbf, hi: 0xbf},
+ // Block 0x3d, offset 0x3e
+ {value: 0x0000, lo: 0x0d},
+ {value: 0x0001, lo: 0x80, hi: 0x8a},
+ {value: 0x04ad, lo: 0x91, hi: 0x91},
+ {value: 0x4281, lo: 0x97, hi: 0x97},
+ {value: 0x001d, lo: 0xa4, hi: 0xa4},
+ {value: 0x19b5, lo: 0xa5, hi: 0xa5},
+ {value: 0x1c9e, lo: 0xa6, hi: 0xa6},
+ {value: 0x0001, lo: 0xaf, hi: 0xaf},
+ {value: 0x283c, lo: 0xb3, hi: 0xb3},
+ {value: 0x29a9, lo: 0xb4, hi: 0xb4},
+ {value: 0x2843, lo: 0xb6, hi: 0xb6},
+ {value: 0x29b3, lo: 0xb7, hi: 0xb7},
+ {value: 0x19af, lo: 0xbc, hi: 0xbc},
+ {value: 0x424f, lo: 0xbe, hi: 0xbe},
+ // Block 0x3e, offset 0x3f
+ {value: 0x0002, lo: 0x0d},
+ {value: 0x1a75, lo: 0x87, hi: 0x87},
+ {value: 0x1a72, lo: 0x88, hi: 0x88},
+ {value: 0x19b2, lo: 0x89, hi: 0x89},
+ {value: 0x2b46, lo: 0x97, hi: 0x97},
+ {value: 0x0001, lo: 0x9f, hi: 0x9f},
+ {value: 0x0021, lo: 0xb0, hi: 0xb0},
+ {value: 0x0093, lo: 0xb1, hi: 0xb1},
+ {value: 0x0029, lo: 0xb4, hi: 0xb9},
+ {value: 0x0017, lo: 0xba, hi: 0xba},
+ {value: 0x04d9, lo: 0xbb, hi: 0xbb},
+ {value: 0x003b, lo: 0xbc, hi: 0xbc},
+ {value: 0x0011, lo: 0xbd, hi: 0xbe},
+ {value: 0x009d, lo: 0xbf, hi: 0xbf},
+ // Block 0x3f, offset 0x40
+ {value: 0x0002, lo: 0x0f},
+ {value: 0x0021, lo: 0x80, hi: 0x89},
+ {value: 0x0017, lo: 0x8a, hi: 0x8a},
+ {value: 0x04d9, lo: 0x8b, hi: 0x8b},
+ {value: 0x003b, lo: 0x8c, hi: 0x8c},
+ {value: 0x0011, lo: 0x8d, hi: 0x8e},
+ {value: 0x0083, lo: 0x90, hi: 0x90},
+ {value: 0x008b, lo: 0x91, hi: 0x91},
+ {value: 0x009f, lo: 0x92, hi: 0x92},
+ {value: 0x00b1, lo: 0x93, hi: 0x93},
+ {value: 0x0107, lo: 0x94, hi: 0x94},
+ {value: 0x0091, lo: 0x95, hi: 0x95},
+ {value: 0x0097, lo: 0x96, hi: 0x99},
+ {value: 0x00a1, lo: 0x9a, hi: 0x9a},
+ {value: 0x00a7, lo: 0x9b, hi: 0x9c},
+ {value: 0x1adb, lo: 0xa8, hi: 0xa8},
+ // Block 0x40, offset 0x41
+ {value: 0x0000, lo: 0x0d},
+ {value: 0x80e6, lo: 0x90, hi: 0x91},
+ {value: 0x8001, lo: 0x92, hi: 0x93},
+ {value: 0x80e6, lo: 0x94, hi: 0x97},
+ {value: 0x8001, lo: 0x98, hi: 0x9a},
+ {value: 0x80e6, lo: 0x9b, hi: 0x9c},
+ {value: 0x80e6, lo: 0xa1, hi: 0xa1},
+ {value: 0x8001, lo: 0xa5, hi: 0xa6},
+ {value: 0x80e6, lo: 0xa7, hi: 0xa7},
+ {value: 0x80dc, lo: 0xa8, hi: 0xa8},
+ {value: 0x80e6, lo: 0xa9, hi: 0xa9},
+ {value: 0x8001, lo: 0xaa, hi: 0xab},
+ {value: 0x80dc, lo: 0xac, hi: 0xaf},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb0},
+ // Block 0x41, offset 0x42
+ {value: 0x0007, lo: 0x06},
+ {value: 0x22c2, lo: 0x89, hi: 0x89},
+ {value: 0x8800, lo: 0x90, hi: 0x90},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x8800, lo: 0x94, hi: 0x94},
+ {value: 0x3ba3, lo: 0x9a, hi: 0x9b},
+ {value: 0x3bb1, lo: 0xae, hi: 0xae},
+ // Block 0x42, offset 0x43
+ {value: 0x000e, lo: 0x05},
+ {value: 0x3bb8, lo: 0x8d, hi: 0x8e},
+ {value: 0x3bbf, lo: 0x8f, hi: 0x8f},
+ {value: 0x8800, lo: 0x90, hi: 0x90},
+ {value: 0x8800, lo: 0x92, hi: 0x92},
+ {value: 0x8800, lo: 0x94, hi: 0x94},
+ // Block 0x43, offset 0x44
+ {value: 0x0173, lo: 0x0e},
+ {value: 0x8800, lo: 0x83, hi: 0x83},
+ {value: 0x3bcd, lo: 0x84, hi: 0x84},
+ {value: 0x8800, lo: 0x88, hi: 0x88},
+ {value: 0x3bd4, lo: 0x89, hi: 0x89},
+ {value: 0x8800, lo: 0x8b, hi: 0x8b},
+ {value: 0x3bdb, lo: 0x8c, hi: 0x8c},
+ {value: 0x8800, lo: 0xa3, hi: 0xa3},
+ {value: 0x3be2, lo: 0xa4, hi: 0xa4},
+ {value: 0x8800, lo: 0xa5, hi: 0xa5},
+ {value: 0x3be9, lo: 0xa6, hi: 0xa6},
+ {value: 0x284a, lo: 0xac, hi: 0xad},
+ {value: 0x2851, lo: 0xaf, hi: 0xaf},
+ {value: 0x29c7, lo: 0xb0, hi: 0xb0},
+ {value: 0x8800, lo: 0xbc, hi: 0xbc},
+ // Block 0x44, offset 0x45
+ {value: 0x0007, lo: 0x03},
+ {value: 0x3c52, lo: 0xa0, hi: 0xa1},
+ {value: 0x3c7c, lo: 0xa2, hi: 0xa3},
+ {value: 0x3ca6, lo: 0xaa, hi: 0xad},
+ // Block 0x45, offset 0x46
+ {value: 0x0004, lo: 0x01},
+ {value: 0x04fd, lo: 0xa9, hi: 0xaa},
+ // Block 0x46, offset 0x47
+ {value: 0x0002, lo: 0x03},
+ {value: 0x0057, lo: 0x80, hi: 0x8f},
+ {value: 0x0083, lo: 0x90, hi: 0xa9},
+ {value: 0x0021, lo: 0xaa, hi: 0xaa},
+ // Block 0x47, offset 0x48
+ {value: 0x0000, lo: 0x01},
+ {value: 0x2b53, lo: 0x8c, hi: 0x8c},
+ // Block 0x48, offset 0x49
+ {value: 0x0263, lo: 0x02},
+ {value: 0x1cce, lo: 0xb4, hi: 0xb4},
+ {value: 0x1a6f, lo: 0xb5, hi: 0xb6},
+ // Block 0x49, offset 0x4a
+ {value: 0x0000, lo: 0x01},
+ {value: 0x44c3, lo: 0x9c, hi: 0x9c},
+ // Block 0x4a, offset 0x4b
+ {value: 0x0000, lo: 0x02},
+ {value: 0x0095, lo: 0xbc, hi: 0xbc},
+ {value: 0x006d, lo: 0xbd, hi: 0xbd},
+ // Block 0x4b, offset 0x4c
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0xaf, hi: 0xb1},
+ // Block 0x4c, offset 0x4d
+ {value: 0x0000, lo: 0x02},
+ {value: 0x04f1, lo: 0xaf, hi: 0xaf},
+ {value: 0x8009, lo: 0xbf, hi: 0xbf},
+ // Block 0x4d, offset 0x4e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0xa0, hi: 0xbf},
+ // Block 0x4e, offset 0x4f
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0e35, lo: 0x9f, hi: 0x9f},
+ // Block 0x4f, offset 0x50
+ {value: 0x0000, lo: 0x01},
+ {value: 0x169d, lo: 0xb3, hi: 0xb3},
+ // Block 0x50, offset 0x51
+ {value: 0x0004, lo: 0x0b},
+ {value: 0x1605, lo: 0x80, hi: 0x82},
+ {value: 0x161d, lo: 0x83, hi: 0x83},
+ {value: 0x1635, lo: 0x84, hi: 0x85},
+ {value: 0x1645, lo: 0x86, hi: 0x89},
+ {value: 0x1659, lo: 0x8a, hi: 0x8c},
+ {value: 0x166d, lo: 0x8d, hi: 0x8d},
+ {value: 0x1675, lo: 0x8e, hi: 0x8e},
+ {value: 0x167d, lo: 0x8f, hi: 0x90},
+ {value: 0x1689, lo: 0x91, hi: 0x93},
+ {value: 0x1699, lo: 0x94, hi: 0x94},
+ {value: 0x16a1, lo: 0x95, hi: 0x95},
+ // Block 0x51, offset 0x52
+ {value: 0x0004, lo: 0x08},
+ {value: 0x0001, lo: 0x80, hi: 0x80},
+ {value: 0x80da, lo: 0xaa, hi: 0xaa},
+ {value: 0x80e4, lo: 0xab, hi: 0xac},
+ {value: 0x80de, lo: 0xad, hi: 0xad},
+ {value: 0x80e0, lo: 0xae, hi: 0xae},
+ {value: 0x80e0, lo: 0xaf, hi: 0xaf},
+ {value: 0x0525, lo: 0xb6, hi: 0xb6},
+ {value: 0x08f9, lo: 0xb8, hi: 0xba},
+ // Block 0x52, offset 0x53
+ {value: 0x0004, lo: 0x06},
+ {value: 0x030d, lo: 0xb1, hi: 0xb2},
+ {value: 0x0435, lo: 0xb3, hi: 0xb3},
+ {value: 0x0315, lo: 0xb4, hi: 0xb4},
+ {value: 0x0439, lo: 0xb5, hi: 0xb6},
+ {value: 0x0319, lo: 0xb7, hi: 0xb9},
+ {value: 0x0441, lo: 0xba, hi: 0xbf},
+ // Block 0x53, offset 0x54
+ {value: 0x0004, lo: 0x0c},
+ {value: 0x0361, lo: 0x80, hi: 0x80},
+ {value: 0x0325, lo: 0x81, hi: 0x83},
+ {value: 0x0375, lo: 0x84, hi: 0x84},
+ {value: 0x0331, lo: 0x85, hi: 0x8e},
+ {value: 0x03c1, lo: 0x8f, hi: 0xa3},
+ {value: 0x03bd, lo: 0xa4, hi: 0xa4},
+ {value: 0x0359, lo: 0xa5, hi: 0xa6},
+ {value: 0x0459, lo: 0xa7, hi: 0xad},
+ {value: 0x0365, lo: 0xae, hi: 0xae},
+ {value: 0x0475, lo: 0xaf, hi: 0xb0},
+ {value: 0x0369, lo: 0xb1, hi: 0xb3},
+ {value: 0x0379, lo: 0xb4, hi: 0xbf},
+ // Block 0x54, offset 0x55
+ {value: 0x0000, lo: 0x02},
+ {value: 0x80e6, lo: 0xaf, hi: 0xaf},
+ {value: 0x80e6, lo: 0xb4, hi: 0xbd},
+ // Block 0x55, offset 0x56
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x9f, hi: 0x9f},
+ // Block 0x56, offset 0x57
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb1},
+ // Block 0x57, offset 0x58
+ {value: 0x0000, lo: 0x01},
+ {value: 0x16a5, lo: 0xb0, hi: 0xb0},
+ // Block 0x58, offset 0x59
+ {value: 0x000c, lo: 0x01},
+ {value: 0x00da, lo: 0xb8, hi: 0xb9},
+ // Block 0x59, offset 0x5a
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x86, hi: 0x86},
+ // Block 0x5a, offset 0x5b
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0x84, hi: 0x84},
+ {value: 0x80e6, lo: 0xa0, hi: 0xb1},
+ // Block 0x5b, offset 0x5c
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0xab, hi: 0xad},
+ // Block 0x5c, offset 0x5d
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x93, hi: 0x93},
+ // Block 0x5d, offset 0x5e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8007, lo: 0xb3, hi: 0xb3},
+ // Block 0x5e, offset 0x5f
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0x80, hi: 0x80},
+ // Block 0x5f, offset 0x60
+ {value: 0x0000, lo: 0x05},
+ {value: 0x80e6, lo: 0xb0, hi: 0xb0},
+ {value: 0x80e6, lo: 0xb2, hi: 0xb3},
+ {value: 0x80dc, lo: 0xb4, hi: 0xb4},
+ {value: 0x80e6, lo: 0xb7, hi: 0xb8},
+ {value: 0x80e6, lo: 0xbe, hi: 0xbf},
+ // Block 0x60, offset 0x61
+ {value: 0x0000, lo: 0x02},
+ {value: 0x80e6, lo: 0x81, hi: 0x81},
+ {value: 0x8009, lo: 0xb6, hi: 0xb6},
+ // Block 0x61, offset 0x62
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8009, lo: 0xad, hi: 0xad},
+ // Block 0x62, offset 0x63
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8100, lo: 0x80, hi: 0xbf},
+ // Block 0x63, offset 0x64
+ {value: 0x0000, lo: 0x01},
+ {value: 0x8100, lo: 0x80, hi: 0xa3},
+ // Block 0x64, offset 0x65
+ {value: 0x0002, lo: 0x01},
+ {value: 0x0003, lo: 0x81, hi: 0xbf},
+ // Block 0x65, offset 0x66
+ {value: 0x0004, lo: 0x0e},
+ {value: 0x03c1, lo: 0x82, hi: 0x87},
+ {value: 0x03d9, lo: 0x8a, hi: 0x8f},
+ {value: 0x03f1, lo: 0x92, hi: 0x97},
+ {value: 0x0409, lo: 0x9a, hi: 0x9c},
+ {value: 0x00bf, lo: 0xa0, hi: 0xa0},
+ {value: 0x00c2, lo: 0xa1, hi: 0xa1},
+ {value: 0x00cb, lo: 0xa2, hi: 0xa2},
+ {value: 0x424a, lo: 0xa3, hi: 0xa3},
+ {value: 0x00c8, lo: 0xa4, hi: 0xa4},
+ {value: 0x00c5, lo: 0xa5, hi: 0xa5},
+ {value: 0x04b9, lo: 0xa6, hi: 0xa6},
+ {value: 0x04dd, lo: 0xa8, hi: 0xa8},
+ {value: 0x04bd, lo: 0xa9, hi: 0xac},
+ {value: 0x04e1, lo: 0xad, hi: 0xae},
+ // Block 0x66, offset 0x67
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80dc, lo: 0xbd, hi: 0xbd},
+ // Block 0x67, offset 0x68
+ {value: 0x00db, lo: 0x05},
+ {value: 0x80dc, lo: 0x8d, hi: 0x8d},
+ {value: 0x80e6, lo: 0x8f, hi: 0x8f},
+ {value: 0x80e6, lo: 0xb8, hi: 0xb8},
+ {value: 0x8001, lo: 0xb9, hi: 0xba},
+ {value: 0x8009, lo: 0xbf, hi: 0xbf},
+ // Block 0x68, offset 0x69
+ {value: 0x05fe, lo: 0x07},
+ {value: 0x8800, lo: 0x99, hi: 0x99},
+ {value: 0x4222, lo: 0x9a, hi: 0x9a},
+ {value: 0x8800, lo: 0x9b, hi: 0x9b},
+ {value: 0x422c, lo: 0x9c, hi: 0x9c},
+ {value: 0x8800, lo: 0xa5, hi: 0xa5},
+ {value: 0x4236, lo: 0xab, hi: 0xab},
+ {value: 0x8009, lo: 0xb9, hi: 0xba},
+ // Block 0x69, offset 0x6a
+ {value: 0x0000, lo: 0x06},
+ {value: 0x80e6, lo: 0x80, hi: 0x82},
+ {value: 0x8600, lo: 0xa7, hi: 0xa7},
+ {value: 0x1993, lo: 0xae, hi: 0xae},
+ {value: 0x199c, lo: 0xaf, hi: 0xaf},
+ {value: 0x8800, lo: 0xb1, hi: 0xb2},
+ {value: 0x8009, lo: 0xb3, hi: 0xb4},
+ // Block 0x6a, offset 0x6b
+ {value: 0x0000, lo: 0x02},
+ {value: 0x8009, lo: 0xb6, hi: 0xb6},
+ {value: 0x8007, lo: 0xb7, hi: 0xb7},
+ // Block 0x6b, offset 0x6c
+ {value: 0x0000, lo: 0x0c},
+ {value: 0x45b2, lo: 0x9e, hi: 0x9e},
+ {value: 0x45bc, lo: 0x9f, hi: 0x9f},
+ {value: 0x45f0, lo: 0xa0, hi: 0xa0},
+ {value: 0x45fe, lo: 0xa1, hi: 0xa1},
+ {value: 0x460c, lo: 0xa2, hi: 0xa2},
+ {value: 0x461a, lo: 0xa3, hi: 0xa3},
+ {value: 0x4628, lo: 0xa4, hi: 0xa4},
+ {value: 0x80d8, lo: 0xa5, hi: 0xa6},
+ {value: 0x8001, lo: 0xa7, hi: 0xa9},
+ {value: 0x80e2, lo: 0xad, hi: 0xad},
+ {value: 0x80d8, lo: 0xae, hi: 0xb2},
+ {value: 0x80dc, lo: 0xbb, hi: 0xbf},
+ // Block 0x6c, offset 0x6d
+ {value: 0x0000, lo: 0x09},
+ {value: 0x80dc, lo: 0x80, hi: 0x82},
+ {value: 0x80e6, lo: 0x85, hi: 0x89},
+ {value: 0x80dc, lo: 0x8a, hi: 0x8b},
+ {value: 0x80e6, lo: 0xaa, hi: 0xad},
+ {value: 0x45c6, lo: 0xbb, hi: 0xbb},
+ {value: 0x45d0, lo: 0xbc, hi: 0xbc},
+ {value: 0x4636, lo: 0xbd, hi: 0xbd},
+ {value: 0x4652, lo: 0xbe, hi: 0xbe},
+ {value: 0x4644, lo: 0xbf, hi: 0xbf},
+ // Block 0x6d, offset 0x6e
+ {value: 0x0000, lo: 0x01},
+ {value: 0x4660, lo: 0x80, hi: 0x80},
+ // Block 0x6e, offset 0x6f
+ {value: 0x0000, lo: 0x01},
+ {value: 0x80e6, lo: 0x82, hi: 0x84},
+ // Block 0x6f, offset 0x70
+ {value: 0x0002, lo: 0x03},
+ {value: 0x0043, lo: 0x80, hi: 0x99},
+ {value: 0x0083, lo: 0x9a, hi: 0xb3},
+ {value: 0x0043, lo: 0xb4, hi: 0xbf},
+ // Block 0x70, offset 0x71
+ {value: 0x0002, lo: 0x04},
+ {value: 0x005b, lo: 0x80, hi: 0x8d},
+ {value: 0x0083, lo: 0x8e, hi: 0x94},
+ {value: 0x0093, lo: 0x96, hi: 0xa7},
+ {value: 0x0043, lo: 0xa8, hi: 0xbf},
+ // Block 0x71, offset 0x72
+ {value: 0x0002, lo: 0x0b},
+ {value: 0x0073, lo: 0x80, hi: 0x81},
+ {value: 0x0083, lo: 0x82, hi: 0x9b},
+ {value: 0x0043, lo: 0x9c, hi: 0x9c},
+ {value: 0x0047, lo: 0x9e, hi: 0x9f},
+ {value: 0x004f, lo: 0xa2, hi: 0xa2},
+ {value: 0x0055, lo: 0xa5, hi: 0xa6},
+ {value: 0x005d, lo: 0xa9, hi: 0xac},
+ {value: 0x0067, lo: 0xae, hi: 0xb5},
+ {value: 0x0083, lo: 0xb6, hi: 0xb9},
+ {value: 0x008d, lo: 0xbb, hi: 0xbb},
+ {value: 0x0091, lo: 0xbd, hi: 0xbf},
+ // Block 0x72, offset 0x73
+ {value: 0x0002, lo: 0x04},
+ {value: 0x0097, lo: 0x80, hi: 0x83},
+ {value: 0x00a1, lo: 0x85, hi: 0x8f},
+ {value: 0x0043, lo: 0x90, hi: 0xa9},
+ {value: 0x0083, lo: 0xaa, hi: 0xbf},
+ // Block 0x73, offset 0x74
+ {value: 0x0002, lo: 0x08},
+ {value: 0x00af, lo: 0x80, hi: 0x83},
+ {value: 0x0043, lo: 0x84, hi: 0x85},
+ {value: 0x0049, lo: 0x87, hi: 0x8a},
+ {value: 0x0055, lo: 0x8d, hi: 0x94},
+ {value: 0x0067, lo: 0x96, hi: 0x9c},
+ {value: 0x0083, lo: 0x9e, hi: 0xb7},
+ {value: 0x0043, lo: 0xb8, hi: 0xb9},
+ {value: 0x0049, lo: 0xbb, hi: 0xbe},
+ // Block 0x74, offset 0x75
+ {value: 0x0002, lo: 0x05},
+ {value: 0x0053, lo: 0x80, hi: 0x84},
+ {value: 0x005f, lo: 0x86, hi: 0x86},
+ {value: 0x0067, lo: 0x8a, hi: 0x90},
+ {value: 0x0083, lo: 0x92, hi: 0xab},
+ {value: 0x0043, lo: 0xac, hi: 0xbf},
+ // Block 0x75, offset 0x76
+ {value: 0x0002, lo: 0x04},
+ {value: 0x006b, lo: 0x80, hi: 0x85},
+ {value: 0x0083, lo: 0x86, hi: 0x9f},
+ {value: 0x0043, lo: 0xa0, hi: 0xb9},
+ {value: 0x0083, lo: 0xba, hi: 0xbf},
+ // Block 0x76, offset 0x77
+ {value: 0x0002, lo: 0x03},
+ {value: 0x008f, lo: 0x80, hi: 0x93},
+ {value: 0x0043, lo: 0x94, hi: 0xad},
+ {value: 0x0083, lo: 0xae, hi: 0xbf},
+ // Block 0x77, offset 0x78
+ {value: 0x0002, lo: 0x04},
+ {value: 0x00a7, lo: 0x80, hi: 0x87},
+ {value: 0x0043, lo: 0x88, hi: 0xa1},
+ {value: 0x0083, lo: 0xa2, hi: 0xbb},
+ {value: 0x0043, lo: 0xbc, hi: 0xbf},
+ // Block 0x78, offset 0x79
+ {value: 0x0002, lo: 0x03},
+ {value: 0x004b, lo: 0x80, hi: 0x95},
+ {value: 0x0083, lo: 0x96, hi: 0xaf},
+ {value: 0x0043, lo: 0xb0, hi: 0xbf},
+ // Block 0x79, offset 0x7a
+ {value: 0x0003, lo: 0x0f},
+ {value: 0x01b8, lo: 0x80, hi: 0x80},
+ {value: 0x04d1, lo: 0x81, hi: 0x81},
+ {value: 0x01bb, lo: 0x82, hi: 0x9a},
+ {value: 0x04cd, lo: 0x9b, hi: 0x9b},
+ {value: 0x01c7, lo: 0x9c, hi: 0x9c},
+ {value: 0x01d0, lo: 0x9d, hi: 0x9d},
+ {value: 0x01d6, lo: 0x9e, hi: 0x9e},
+ {value: 0x01fa, lo: 0x9f, hi: 0x9f},
+ {value: 0x01eb, lo: 0xa0, hi: 0xa0},
+ {value: 0x01e8, lo: 0xa1, hi: 0xa1},
+ {value: 0x0173, lo: 0xa2, hi: 0xb2},
+ {value: 0x0188, lo: 0xb3, hi: 0xb3},
+ {value: 0x01a6, lo: 0xb4, hi: 0xba},
+ {value: 0x04d1, lo: 0xbb, hi: 0xbb},
+ {value: 0x01bb, lo: 0xbc, hi: 0xbf},
+ // Block 0x7a, offset 0x7b
+ {value: 0x0003, lo: 0x0d},
+ {value: 0x01c7, lo: 0x80, hi: 0x94},
+ {value: 0x04cd, lo: 0x95, hi: 0x95},
+ {value: 0x01c7, lo: 0x96, hi: 0x96},
+ {value: 0x01d0, lo: 0x97, hi: 0x97},
+ {value: 0x01d6, lo: 0x98, hi: 0x98},
+ {value: 0x01fa, lo: 0x99, hi: 0x99},
+ {value: 0x01eb, lo: 0x9a, hi: 0x9a},
+ {value: 0x01e8, lo: 0x9b, hi: 0x9b},
+ {value: 0x0173, lo: 0x9c, hi: 0xac},
+ {value: 0x0188, lo: 0xad, hi: 0xad},
+ {value: 0x01a6, lo: 0xae, hi: 0xb4},
+ {value: 0x04d1, lo: 0xb5, hi: 0xb5},
+ {value: 0x01bb, lo: 0xb6, hi: 0xbf},
+ // Block 0x7b, offset 0x7c
+ {value: 0x0003, lo: 0x0d},
+ {value: 0x01d9, lo: 0x80, hi: 0x8e},
+ {value: 0x04cd, lo: 0x8f, hi: 0x8f},
+ {value: 0x01c7, lo: 0x90, hi: 0x90},
+ {value: 0x01d0, lo: 0x91, hi: 0x91},
+ {value: 0x01d6, lo: 0x92, hi: 0x92},
+ {value: 0x01fa, lo: 0x93, hi: 0x93},
+ {value: 0x01eb, lo: 0x94, hi: 0x94},
+ {value: 0x01e8, lo: 0x95, hi: 0x95},
+ {value: 0x0173, lo: 0x96, hi: 0xa6},
+ {value: 0x0188, lo: 0xa7, hi: 0xa7},
+ {value: 0x01a6, lo: 0xa8, hi: 0xae},
+ {value: 0x04d1, lo: 0xaf, hi: 0xaf},
+ {value: 0x01bb, lo: 0xb0, hi: 0xbf},
+ // Block 0x7c, offset 0x7d
+ {value: 0x0003, lo: 0x0d},
+ {value: 0x01eb, lo: 0x80, hi: 0x88},
+ {value: 0x04cd, lo: 0x89, hi: 0x89},
+ {value: 0x01c7, lo: 0x8a, hi: 0x8a},
+ {value: 0x01d0, lo: 0x8b, hi: 0x8b},
+ {value: 0x01d6, lo: 0x8c, hi: 0x8c},
+ {value: 0x01fa, lo: 0x8d, hi: 0x8d},
+ {value: 0x01eb, lo: 0x8e, hi: 0x8e},
+ {value: 0x01e8, lo: 0x8f, hi: 0x8f},
+ {value: 0x0173, lo: 0x90, hi: 0xa0},
+ {value: 0x0188, lo: 0xa1, hi: 0xa1},
+ {value: 0x01a6, lo: 0xa2, hi: 0xa8},
+ {value: 0x04d1, lo: 0xa9, hi: 0xa9},
+ {value: 0x01bb, lo: 0xaa, hi: 0xbf},
+ // Block 0x7d, offset 0x7e
+ {value: 0x0002, lo: 0x09},
+ {value: 0x0063, lo: 0x80, hi: 0x89},
+ {value: 0x1a93, lo: 0x8a, hi: 0x8a},
+ {value: 0x1ac3, lo: 0x8b, hi: 0x8b},
+ {value: 0x1ade, lo: 0x8c, hi: 0x8c},
+ {value: 0x1ae4, lo: 0x8d, hi: 0x8d},
+ {value: 0x1d02, lo: 0x8e, hi: 0x8e},
+ {value: 0x1af0, lo: 0x8f, hi: 0x8f},
+ {value: 0x1abd, lo: 0xaa, hi: 0xaa},
+ {value: 0x1ac0, lo: 0xab, hi: 0xab},
+ // Block 0x7e, offset 0x7f
+ {value: 0x0000, lo: 0x01},
+ {value: 0x1a81, lo: 0x90, hi: 0x90},
+ // Block 0x7f, offset 0x80
+ {value: 0x0028, lo: 0x09},
+ {value: 0x2a0d, lo: 0x80, hi: 0x80},
+ {value: 0x29d1, lo: 0x81, hi: 0x81},
+ {value: 0x29db, lo: 0x82, hi: 0x82},
+ {value: 0x29ef, lo: 0x83, hi: 0x84},
+ {value: 0x29f9, lo: 0x85, hi: 0x86},
+ {value: 0x29e5, lo: 0x87, hi: 0x87},
+ {value: 0x2a03, lo: 0x88, hi: 0x88},
+ {value: 0x0be1, lo: 0x90, hi: 0x90},
+ {value: 0x0959, lo: 0x91, hi: 0x91},
+}
+
+// nfkcLookup: 1216 bytes
+// Block 0 is the null block.
+var nfkcLookup = [1216]uint8{
+ // Block 0x0, offset 0x0
+ // Block 0x1, offset 0x40
+ // Block 0x2, offset 0x80
+ // Block 0x3, offset 0xc0
+ 0x0c2: 0x58, 0x0c3: 0x01, 0x0c4: 0x02, 0x0c5: 0x03, 0x0c6: 0x59, 0x0c7: 0x04,
+ 0x0c8: 0x05, 0x0ca: 0x5a, 0x0cb: 0x5b, 0x0cc: 0x06, 0x0cd: 0x07, 0x0ce: 0x08, 0x0cf: 0x09,
+ 0x0d0: 0x0a, 0x0d1: 0x5c, 0x0d2: 0x5d, 0x0d3: 0x0b, 0x0d6: 0x0c, 0x0d7: 0x5e,
+ 0x0d8: 0x5f, 0x0d9: 0x0d, 0x0db: 0x60, 0x0dc: 0x61, 0x0dd: 0x62, 0x0df: 0x63,
+ 0x0e0: 0x02, 0x0e1: 0x03, 0x0e2: 0x04, 0x0e3: 0x05,
+ 0x0ea: 0x06, 0x0eb: 0x07, 0x0ec: 0x07, 0x0ed: 0x08, 0x0ef: 0x09,
+ 0x0f0: 0x10,
+ // Block 0x4, offset 0x100
+ 0x120: 0x64, 0x121: 0x65, 0x123: 0x66, 0x124: 0x67, 0x125: 0x68, 0x126: 0x69, 0x127: 0x6a,
+ 0x128: 0x6b, 0x129: 0x6c, 0x12a: 0x6d, 0x12b: 0x6e, 0x12c: 0x69, 0x12d: 0x6f, 0x12e: 0x70, 0x12f: 0x71,
+ 0x131: 0x72, 0x132: 0x73, 0x133: 0x74, 0x134: 0x75, 0x135: 0x76, 0x137: 0x77,
+ 0x138: 0x78, 0x139: 0x79, 0x13a: 0x7a, 0x13b: 0x7b, 0x13c: 0x7c, 0x13d: 0x7d, 0x13e: 0x7e, 0x13f: 0x7f,
+ // Block 0x5, offset 0x140
+ 0x140: 0x80, 0x142: 0x81, 0x143: 0x82, 0x144: 0x83, 0x145: 0x84, 0x146: 0x85, 0x147: 0x86,
+ 0x14d: 0x87,
+ 0x15c: 0x88, 0x15f: 0x89,
+ 0x162: 0x8a, 0x164: 0x8b,
+ 0x168: 0x8c, 0x169: 0x8d, 0x16c: 0x0e, 0x16d: 0x8e, 0x16e: 0x8f, 0x16f: 0x90,
+ 0x170: 0x91, 0x173: 0x92, 0x174: 0x93, 0x175: 0x0f, 0x176: 0x10, 0x177: 0x94,
+ 0x178: 0x11, 0x179: 0x12, 0x17a: 0x13, 0x17b: 0x14, 0x17c: 0x15, 0x17d: 0x16, 0x17e: 0x17, 0x17f: 0x18,
+ // Block 0x6, offset 0x180
+ 0x180: 0x95, 0x181: 0x96, 0x182: 0x97, 0x183: 0x98, 0x184: 0x19, 0x185: 0x1a, 0x186: 0x99, 0x187: 0x9a,
+ 0x188: 0x9b, 0x189: 0x1b, 0x18a: 0x1c, 0x18b: 0x9c, 0x18c: 0x9d,
+ 0x191: 0x1d, 0x192: 0x1e, 0x193: 0x9e,
+ 0x1a8: 0x9f, 0x1a9: 0xa0, 0x1ab: 0xa1,
+ 0x1b1: 0xa2, 0x1b3: 0xa3, 0x1b5: 0xa4, 0x1b7: 0xa5,
+ 0x1ba: 0xa6, 0x1bb: 0xa7, 0x1bc: 0x1f, 0x1bd: 0x20, 0x1be: 0x21, 0x1bf: 0xa8,
+ // Block 0x7, offset 0x1c0
+ 0x1c0: 0xa9, 0x1c1: 0x22, 0x1c2: 0x23, 0x1c3: 0x24, 0x1c4: 0xaa, 0x1c5: 0xab, 0x1c6: 0x25,
+ 0x1c8: 0x26, 0x1c9: 0x27, 0x1ca: 0x28, 0x1cb: 0x29, 0x1cc: 0x2a, 0x1cd: 0x2b, 0x1ce: 0x2c, 0x1cf: 0x2d,
+ // Block 0x8, offset 0x200
+ 0x219: 0xac, 0x21a: 0xad, 0x21b: 0xae, 0x21d: 0xaf, 0x21f: 0xb0,
+ 0x220: 0xb1, 0x223: 0xb2, 0x224: 0xb3, 0x225: 0xb4, 0x226: 0xb5, 0x227: 0xb6,
+ 0x22a: 0xb7, 0x22b: 0xb8, 0x22f: 0xb9,
+ 0x230: 0xba, 0x231: 0xba, 0x232: 0xba, 0x233: 0xba, 0x234: 0xba, 0x235: 0xba, 0x236: 0xba, 0x237: 0xba,
+ 0x238: 0xba, 0x239: 0xba, 0x23a: 0xba, 0x23b: 0xba, 0x23c: 0xba, 0x23d: 0xba, 0x23e: 0xba, 0x23f: 0xba,
+ // Block 0x9, offset 0x240
+ 0x240: 0xba, 0x241: 0xba, 0x242: 0xba, 0x243: 0xba, 0x244: 0xba, 0x245: 0xba, 0x246: 0xba, 0x247: 0xba,
+ 0x248: 0xba, 0x249: 0xba, 0x24a: 0xba, 0x24b: 0xba, 0x24c: 0xba, 0x24d: 0xba, 0x24e: 0xba, 0x24f: 0xba,
+ 0x250: 0xba, 0x251: 0xba, 0x252: 0xba, 0x253: 0xba, 0x254: 0xba, 0x255: 0xba, 0x256: 0xba, 0x257: 0xba,
+ 0x258: 0xba, 0x259: 0xba, 0x25a: 0xba, 0x25b: 0xba, 0x25c: 0xba, 0x25d: 0xba, 0x25e: 0xba, 0x25f: 0xba,
+ 0x260: 0xba, 0x261: 0xba, 0x262: 0xba, 0x263: 0xba, 0x264: 0xba, 0x265: 0xba, 0x266: 0xba, 0x267: 0xba,
+ 0x268: 0xba, 0x269: 0xba, 0x26a: 0xba, 0x26b: 0xba, 0x26c: 0xba, 0x26d: 0xba, 0x26e: 0xba, 0x26f: 0xba,
+ 0x270: 0xba, 0x271: 0xba, 0x272: 0xba, 0x273: 0xba, 0x274: 0xba, 0x275: 0xba, 0x276: 0xba, 0x277: 0xba,
+ 0x278: 0xba, 0x279: 0xba, 0x27a: 0xba, 0x27b: 0xba, 0x27c: 0xba, 0x27d: 0xba, 0x27e: 0xba, 0x27f: 0xba,
+ // Block 0xa, offset 0x280
+ 0x280: 0xba, 0x281: 0xba, 0x282: 0xba, 0x283: 0xba, 0x284: 0xba, 0x285: 0xba, 0x286: 0xba, 0x287: 0xba,
+ 0x288: 0xba, 0x289: 0xba, 0x28a: 0xba, 0x28b: 0xba, 0x28c: 0xba, 0x28d: 0xba, 0x28e: 0xba, 0x28f: 0xba,
+ 0x290: 0xba, 0x291: 0xba, 0x292: 0xba, 0x293: 0xba, 0x294: 0xba, 0x295: 0xba, 0x296: 0xba, 0x297: 0xba,
+ 0x298: 0xba, 0x299: 0xba, 0x29a: 0xba, 0x29b: 0xba, 0x29c: 0xba, 0x29d: 0xba, 0x29e: 0xbb,
+ // Block 0xb, offset 0x2c0
+ 0x2e4: 0x2e, 0x2e5: 0x2f, 0x2e6: 0x30, 0x2e7: 0x31,
+ 0x2e8: 0x32, 0x2e9: 0x33, 0x2ea: 0x34, 0x2eb: 0x35, 0x2ec: 0x36, 0x2ed: 0x37, 0x2ee: 0x38, 0x2ef: 0x39,
+ 0x2f0: 0x3a, 0x2f1: 0x3b, 0x2f2: 0x3c, 0x2f3: 0x3d, 0x2f4: 0x3e, 0x2f5: 0x3f, 0x2f6: 0x40, 0x2f7: 0x41,
+ 0x2f8: 0x42, 0x2f9: 0x43, 0x2fa: 0x44, 0x2fb: 0x45, 0x2fc: 0xbc, 0x2fd: 0x46, 0x2fe: 0x47, 0x2ff: 0xbd,
+ // Block 0xc, offset 0x300
+ 0x307: 0xbe,
+ 0x328: 0xbf,
+ // Block 0xd, offset 0x340
+ 0x341: 0xb1, 0x342: 0xc0, 0x344: 0xc1, 0x347: 0xb6,
+ 0x35a: 0xc2,
+ // Block 0xe, offset 0x380
+ 0x385: 0xc3, 0x386: 0xc4, 0x387: 0xc5,
+ 0x389: 0xc6,
+ 0x390: 0xc7, 0x391: 0xc8, 0x392: 0xc9, 0x393: 0xca, 0x394: 0xcb, 0x395: 0xcc, 0x396: 0xcd, 0x397: 0xce,
+ 0x398: 0xcf, 0x399: 0xd0, 0x39a: 0x48, 0x39b: 0xd1, 0x39c: 0xd2, 0x39d: 0xd3, 0x39e: 0xd4, 0x39f: 0x49,
+ // Block 0xf, offset 0x3c0
+ 0x3f8: 0x4a, 0x3f9: 0x4b, 0x3fa: 0x4c,
+ // Block 0x10, offset 0x400
+ 0x404: 0x4d, 0x405: 0xd5, 0x406: 0xd6,
+ 0x408: 0x4e, 0x409: 0xd7,
+ // Block 0x11, offset 0x440
+ 0x460: 0x4f, 0x461: 0x50, 0x462: 0x51, 0x463: 0x52, 0x464: 0x53, 0x465: 0x54, 0x466: 0x55, 0x467: 0x56,
+ 0x468: 0x57,
+ // Block 0x12, offset 0x480
+ 0x490: 0x0a, 0x491: 0x0b,
+ 0x49d: 0x0c, 0x49e: 0x0d, 0x49f: 0x0e,
+ 0x4af: 0x0f,
+}
+
+var nfkcTrie = trie{nfkcLookup[:], nfkcValues[:], nfkcSparseValues[:], nfkcSparseOffset[:], 88}
+
+// recompMap: 7464 bytes (entries only)
+var recompMap = map[uint32]rune{
+ 0x00410300: 0x00C0,
+ 0x00410301: 0x00C1,
+ 0x00410302: 0x00C2,
+ 0x00410303: 0x00C3,
+ 0x00410308: 0x00C4,
+ 0x0041030A: 0x00C5,
+ 0x00430327: 0x00C7,
+ 0x00450300: 0x00C8,
+ 0x00450301: 0x00C9,
+ 0x00450302: 0x00CA,
+ 0x00450308: 0x00CB,
+ 0x00490300: 0x00CC,
+ 0x00490301: 0x00CD,
+ 0x00490302: 0x00CE,
+ 0x00490308: 0x00CF,
+ 0x004E0303: 0x00D1,
+ 0x004F0300: 0x00D2,
+ 0x004F0301: 0x00D3,
+ 0x004F0302: 0x00D4,
+ 0x004F0303: 0x00D5,
+ 0x004F0308: 0x00D6,
+ 0x00550300: 0x00D9,
+ 0x00550301: 0x00DA,
+ 0x00550302: 0x00DB,
+ 0x00550308: 0x00DC,
+ 0x00590301: 0x00DD,
+ 0x00610300: 0x00E0,
+ 0x00610301: 0x00E1,
+ 0x00610302: 0x00E2,
+ 0x00610303: 0x00E3,
+ 0x00610308: 0x00E4,
+ 0x0061030A: 0x00E5,
+ 0x00630327: 0x00E7,
+ 0x00650300: 0x00E8,
+ 0x00650301: 0x00E9,
+ 0x00650302: 0x00EA,
+ 0x00650308: 0x00EB,
+ 0x00690300: 0x00EC,
+ 0x00690301: 0x00ED,
+ 0x00690302: 0x00EE,
+ 0x00690308: 0x00EF,
+ 0x006E0303: 0x00F1,
+ 0x006F0300: 0x00F2,
+ 0x006F0301: 0x00F3,
+ 0x006F0302: 0x00F4,
+ 0x006F0303: 0x00F5,
+ 0x006F0308: 0x00F6,
+ 0x00750300: 0x00F9,
+ 0x00750301: 0x00FA,
+ 0x00750302: 0x00FB,
+ 0x00750308: 0x00FC,
+ 0x00790301: 0x00FD,
+ 0x00790308: 0x00FF,
+ 0x00410304: 0x0100,
+ 0x00610304: 0x0101,
+ 0x00410306: 0x0102,
+ 0x00610306: 0x0103,
+ 0x00410328: 0x0104,
+ 0x00610328: 0x0105,
+ 0x00430301: 0x0106,
+ 0x00630301: 0x0107,
+ 0x00430302: 0x0108,
+ 0x00630302: 0x0109,
+ 0x00430307: 0x010A,
+ 0x00630307: 0x010B,
+ 0x0043030C: 0x010C,
+ 0x0063030C: 0x010D,
+ 0x0044030C: 0x010E,
+ 0x0064030C: 0x010F,
+ 0x00450304: 0x0112,
+ 0x00650304: 0x0113,
+ 0x00450306: 0x0114,
+ 0x00650306: 0x0115,
+ 0x00450307: 0x0116,
+ 0x00650307: 0x0117,
+ 0x00450328: 0x0118,
+ 0x00650328: 0x0119,
+ 0x0045030C: 0x011A,
+ 0x0065030C: 0x011B,
+ 0x00470302: 0x011C,
+ 0x00670302: 0x011D,
+ 0x00470306: 0x011E,
+ 0x00670306: 0x011F,
+ 0x00470307: 0x0120,
+ 0x00670307: 0x0121,
+ 0x00470327: 0x0122,
+ 0x00670327: 0x0123,
+ 0x00480302: 0x0124,
+ 0x00680302: 0x0125,
+ 0x00490303: 0x0128,
+ 0x00690303: 0x0129,
+ 0x00490304: 0x012A,
+ 0x00690304: 0x012B,
+ 0x00490306: 0x012C,
+ 0x00690306: 0x012D,
+ 0x00490328: 0x012E,
+ 0x00690328: 0x012F,
+ 0x00490307: 0x0130,
+ 0x004A0302: 0x0134,
+ 0x006A0302: 0x0135,
+ 0x004B0327: 0x0136,
+ 0x006B0327: 0x0137,
+ 0x004C0301: 0x0139,
+ 0x006C0301: 0x013A,
+ 0x004C0327: 0x013B,
+ 0x006C0327: 0x013C,
+ 0x004C030C: 0x013D,
+ 0x006C030C: 0x013E,
+ 0x004E0301: 0x0143,
+ 0x006E0301: 0x0144,
+ 0x004E0327: 0x0145,
+ 0x006E0327: 0x0146,
+ 0x004E030C: 0x0147,
+ 0x006E030C: 0x0148,
+ 0x004F0304: 0x014C,
+ 0x006F0304: 0x014D,
+ 0x004F0306: 0x014E,
+ 0x006F0306: 0x014F,
+ 0x004F030B: 0x0150,
+ 0x006F030B: 0x0151,
+ 0x00520301: 0x0154,
+ 0x00720301: 0x0155,
+ 0x00520327: 0x0156,
+ 0x00720327: 0x0157,
+ 0x0052030C: 0x0158,
+ 0x0072030C: 0x0159,
+ 0x00530301: 0x015A,
+ 0x00730301: 0x015B,
+ 0x00530302: 0x015C,
+ 0x00730302: 0x015D,
+ 0x00530327: 0x015E,
+ 0x00730327: 0x015F,
+ 0x0053030C: 0x0160,
+ 0x0073030C: 0x0161,
+ 0x00540327: 0x0162,
+ 0x00740327: 0x0163,
+ 0x0054030C: 0x0164,
+ 0x0074030C: 0x0165,
+ 0x00550303: 0x0168,
+ 0x00750303: 0x0169,
+ 0x00550304: 0x016A,
+ 0x00750304: 0x016B,
+ 0x00550306: 0x016C,
+ 0x00750306: 0x016D,
+ 0x0055030A: 0x016E,
+ 0x0075030A: 0x016F,
+ 0x0055030B: 0x0170,
+ 0x0075030B: 0x0171,
+ 0x00550328: 0x0172,
+ 0x00750328: 0x0173,
+ 0x00570302: 0x0174,
+ 0x00770302: 0x0175,
+ 0x00590302: 0x0176,
+ 0x00790302: 0x0177,
+ 0x00590308: 0x0178,
+ 0x005A0301: 0x0179,
+ 0x007A0301: 0x017A,
+ 0x005A0307: 0x017B,
+ 0x007A0307: 0x017C,
+ 0x005A030C: 0x017D,
+ 0x007A030C: 0x017E,
+ 0x004F031B: 0x01A0,
+ 0x006F031B: 0x01A1,
+ 0x0055031B: 0x01AF,
+ 0x0075031B: 0x01B0,
+ 0x0041030C: 0x01CD,
+ 0x0061030C: 0x01CE,
+ 0x0049030C: 0x01CF,
+ 0x0069030C: 0x01D0,
+ 0x004F030C: 0x01D1,
+ 0x006F030C: 0x01D2,
+ 0x0055030C: 0x01D3,
+ 0x0075030C: 0x01D4,
+ 0x00DC0304: 0x01D5,
+ 0x00FC0304: 0x01D6,
+ 0x00DC0301: 0x01D7,
+ 0x00FC0301: 0x01D8,
+ 0x00DC030C: 0x01D9,
+ 0x00FC030C: 0x01DA,
+ 0x00DC0300: 0x01DB,
+ 0x00FC0300: 0x01DC,
+ 0x00C40304: 0x01DE,
+ 0x00E40304: 0x01DF,
+ 0x02260304: 0x01E0,
+ 0x02270304: 0x01E1,
+ 0x00C60304: 0x01E2,
+ 0x00E60304: 0x01E3,
+ 0x0047030C: 0x01E6,
+ 0x0067030C: 0x01E7,
+ 0x004B030C: 0x01E8,
+ 0x006B030C: 0x01E9,
+ 0x004F0328: 0x01EA,
+ 0x006F0328: 0x01EB,
+ 0x01EA0304: 0x01EC,
+ 0x01EB0304: 0x01ED,
+ 0x01B7030C: 0x01EE,
+ 0x0292030C: 0x01EF,
+ 0x006A030C: 0x01F0,
+ 0x00470301: 0x01F4,
+ 0x00670301: 0x01F5,
+ 0x004E0300: 0x01F8,
+ 0x006E0300: 0x01F9,
+ 0x00C50301: 0x01FA,
+ 0x00E50301: 0x01FB,
+ 0x00C60301: 0x01FC,
+ 0x00E60301: 0x01FD,
+ 0x00D80301: 0x01FE,
+ 0x00F80301: 0x01FF,
+ 0x0041030F: 0x0200,
+ 0x0061030F: 0x0201,
+ 0x00410311: 0x0202,
+ 0x00610311: 0x0203,
+ 0x0045030F: 0x0204,
+ 0x0065030F: 0x0205,
+ 0x00450311: 0x0206,
+ 0x00650311: 0x0207,
+ 0x0049030F: 0x0208,
+ 0x0069030F: 0x0209,
+ 0x00490311: 0x020A,
+ 0x00690311: 0x020B,
+ 0x004F030F: 0x020C,
+ 0x006F030F: 0x020D,
+ 0x004F0311: 0x020E,
+ 0x006F0311: 0x020F,
+ 0x0052030F: 0x0210,
+ 0x0072030F: 0x0211,
+ 0x00520311: 0x0212,
+ 0x00720311: 0x0213,
+ 0x0055030F: 0x0214,
+ 0x0075030F: 0x0215,
+ 0x00550311: 0x0216,
+ 0x00750311: 0x0217,
+ 0x00530326: 0x0218,
+ 0x00730326: 0x0219,
+ 0x00540326: 0x021A,
+ 0x00740326: 0x021B,
+ 0x0048030C: 0x021E,
+ 0x0068030C: 0x021F,
+ 0x00410307: 0x0226,
+ 0x00610307: 0x0227,
+ 0x00450327: 0x0228,
+ 0x00650327: 0x0229,
+ 0x00D60304: 0x022A,
+ 0x00F60304: 0x022B,
+ 0x00D50304: 0x022C,
+ 0x00F50304: 0x022D,
+ 0x004F0307: 0x022E,
+ 0x006F0307: 0x022F,
+ 0x022E0304: 0x0230,
+ 0x022F0304: 0x0231,
+ 0x00590304: 0x0232,
+ 0x00790304: 0x0233,
+ 0x00A80301: 0x0385,
+ 0x03910301: 0x0386,
+ 0x03950301: 0x0388,
+ 0x03970301: 0x0389,
+ 0x03990301: 0x038A,
+ 0x039F0301: 0x038C,
+ 0x03A50301: 0x038E,
+ 0x03A90301: 0x038F,
+ 0x03CA0301: 0x0390,
+ 0x03990308: 0x03AA,
+ 0x03A50308: 0x03AB,
+ 0x03B10301: 0x03AC,
+ 0x03B50301: 0x03AD,
+ 0x03B70301: 0x03AE,
+ 0x03B90301: 0x03AF,
+ 0x03CB0301: 0x03B0,
+ 0x03B90308: 0x03CA,
+ 0x03C50308: 0x03CB,
+ 0x03BF0301: 0x03CC,
+ 0x03C50301: 0x03CD,
+ 0x03C90301: 0x03CE,
+ 0x03D20301: 0x03D3,
+ 0x03D20308: 0x03D4,
+ 0x04150300: 0x0400,
+ 0x04150308: 0x0401,
+ 0x04130301: 0x0403,
+ 0x04060308: 0x0407,
+ 0x041A0301: 0x040C,
+ 0x04180300: 0x040D,
+ 0x04230306: 0x040E,
+ 0x04180306: 0x0419,
+ 0x04380306: 0x0439,
+ 0x04350300: 0x0450,
+ 0x04350308: 0x0451,
+ 0x04330301: 0x0453,
+ 0x04560308: 0x0457,
+ 0x043A0301: 0x045C,
+ 0x04380300: 0x045D,
+ 0x04430306: 0x045E,
+ 0x0474030F: 0x0476,
+ 0x0475030F: 0x0477,
+ 0x04160306: 0x04C1,
+ 0x04360306: 0x04C2,
+ 0x04100306: 0x04D0,
+ 0x04300306: 0x04D1,
+ 0x04100308: 0x04D2,
+ 0x04300308: 0x04D3,
+ 0x04150306: 0x04D6,
+ 0x04350306: 0x04D7,
+ 0x04D80308: 0x04DA,
+ 0x04D90308: 0x04DB,
+ 0x04160308: 0x04DC,
+ 0x04360308: 0x04DD,
+ 0x04170308: 0x04DE,
+ 0x04370308: 0x04DF,
+ 0x04180304: 0x04E2,
+ 0x04380304: 0x04E3,
+ 0x04180308: 0x04E4,
+ 0x04380308: 0x04E5,
+ 0x041E0308: 0x04E6,
+ 0x043E0308: 0x04E7,
+ 0x04E80308: 0x04EA,
+ 0x04E90308: 0x04EB,
+ 0x042D0308: 0x04EC,
+ 0x044D0308: 0x04ED,
+ 0x04230304: 0x04EE,
+ 0x04430304: 0x04EF,
+ 0x04230308: 0x04F0,
+ 0x04430308: 0x04F1,
+ 0x0423030B: 0x04F2,
+ 0x0443030B: 0x04F3,
+ 0x04270308: 0x04F4,
+ 0x04470308: 0x04F5,
+ 0x042B0308: 0x04F8,
+ 0x044B0308: 0x04F9,
+ 0x06270653: 0x0622,
+ 0x06270654: 0x0623,
+ 0x06480654: 0x0624,
+ 0x06270655: 0x0625,
+ 0x064A0654: 0x0626,
+ 0x06D50654: 0x06C0,
+ 0x06C10654: 0x06C2,
+ 0x06D20654: 0x06D3,
+ 0x0928093C: 0x0929,
+ 0x0930093C: 0x0931,
+ 0x0933093C: 0x0934,
+ 0x09C709BE: 0x09CB,
+ 0x09C709D7: 0x09CC,
+ 0x0B470B56: 0x0B48,
+ 0x0B470B3E: 0x0B4B,
+ 0x0B470B57: 0x0B4C,
+ 0x0B920BD7: 0x0B94,
+ 0x0BC60BBE: 0x0BCA,
+ 0x0BC70BBE: 0x0BCB,
+ 0x0BC60BD7: 0x0BCC,
+ 0x0C460C56: 0x0C48,
+ 0x0CBF0CD5: 0x0CC0,
+ 0x0CC60CD5: 0x0CC7,
+ 0x0CC60CD6: 0x0CC8,
+ 0x0CC60CC2: 0x0CCA,
+ 0x0CCA0CD5: 0x0CCB,
+ 0x0D460D3E: 0x0D4A,
+ 0x0D470D3E: 0x0D4B,
+ 0x0D460D57: 0x0D4C,
+ 0x0DD90DCA: 0x0DDA,
+ 0x0DD90DCF: 0x0DDC,
+ 0x0DDC0DCA: 0x0DDD,
+ 0x0DD90DDF: 0x0DDE,
+ 0x1025102E: 0x1026,
+ 0x1B051B35: 0x1B06,
+ 0x1B071B35: 0x1B08,
+ 0x1B091B35: 0x1B0A,
+ 0x1B0B1B35: 0x1B0C,
+ 0x1B0D1B35: 0x1B0E,
+ 0x1B111B35: 0x1B12,
+ 0x1B3A1B35: 0x1B3B,
+ 0x1B3C1B35: 0x1B3D,
+ 0x1B3E1B35: 0x1B40,
+ 0x1B3F1B35: 0x1B41,
+ 0x1B421B35: 0x1B43,
+ 0x00410325: 0x1E00,
+ 0x00610325: 0x1E01,
+ 0x00420307: 0x1E02,
+ 0x00620307: 0x1E03,
+ 0x00420323: 0x1E04,
+ 0x00620323: 0x1E05,
+ 0x00420331: 0x1E06,
+ 0x00620331: 0x1E07,
+ 0x00C70301: 0x1E08,
+ 0x00E70301: 0x1E09,
+ 0x00440307: 0x1E0A,
+ 0x00640307: 0x1E0B,
+ 0x00440323: 0x1E0C,
+ 0x00640323: 0x1E0D,
+ 0x00440331: 0x1E0E,
+ 0x00640331: 0x1E0F,
+ 0x00440327: 0x1E10,
+ 0x00640327: 0x1E11,
+ 0x0044032D: 0x1E12,
+ 0x0064032D: 0x1E13,
+ 0x01120300: 0x1E14,
+ 0x01130300: 0x1E15,
+ 0x01120301: 0x1E16,
+ 0x01130301: 0x1E17,
+ 0x0045032D: 0x1E18,
+ 0x0065032D: 0x1E19,
+ 0x00450330: 0x1E1A,
+ 0x00650330: 0x1E1B,
+ 0x02280306: 0x1E1C,
+ 0x02290306: 0x1E1D,
+ 0x00460307: 0x1E1E,
+ 0x00660307: 0x1E1F,
+ 0x00470304: 0x1E20,
+ 0x00670304: 0x1E21,
+ 0x00480307: 0x1E22,
+ 0x00680307: 0x1E23,
+ 0x00480323: 0x1E24,
+ 0x00680323: 0x1E25,
+ 0x00480308: 0x1E26,
+ 0x00680308: 0x1E27,
+ 0x00480327: 0x1E28,
+ 0x00680327: 0x1E29,
+ 0x0048032E: 0x1E2A,
+ 0x0068032E: 0x1E2B,
+ 0x00490330: 0x1E2C,
+ 0x00690330: 0x1E2D,
+ 0x00CF0301: 0x1E2E,
+ 0x00EF0301: 0x1E2F,
+ 0x004B0301: 0x1E30,
+ 0x006B0301: 0x1E31,
+ 0x004B0323: 0x1E32,
+ 0x006B0323: 0x1E33,
+ 0x004B0331: 0x1E34,
+ 0x006B0331: 0x1E35,
+ 0x004C0323: 0x1E36,
+ 0x006C0323: 0x1E37,
+ 0x1E360304: 0x1E38,
+ 0x1E370304: 0x1E39,
+ 0x004C0331: 0x1E3A,
+ 0x006C0331: 0x1E3B,
+ 0x004C032D: 0x1E3C,
+ 0x006C032D: 0x1E3D,
+ 0x004D0301: 0x1E3E,
+ 0x006D0301: 0x1E3F,
+ 0x004D0307: 0x1E40,
+ 0x006D0307: 0x1E41,
+ 0x004D0323: 0x1E42,
+ 0x006D0323: 0x1E43,
+ 0x004E0307: 0x1E44,
+ 0x006E0307: 0x1E45,
+ 0x004E0323: 0x1E46,
+ 0x006E0323: 0x1E47,
+ 0x004E0331: 0x1E48,
+ 0x006E0331: 0x1E49,
+ 0x004E032D: 0x1E4A,
+ 0x006E032D: 0x1E4B,
+ 0x00D50301: 0x1E4C,
+ 0x00F50301: 0x1E4D,
+ 0x00D50308: 0x1E4E,
+ 0x00F50308: 0x1E4F,
+ 0x014C0300: 0x1E50,
+ 0x014D0300: 0x1E51,
+ 0x014C0301: 0x1E52,
+ 0x014D0301: 0x1E53,
+ 0x00500301: 0x1E54,
+ 0x00700301: 0x1E55,
+ 0x00500307: 0x1E56,
+ 0x00700307: 0x1E57,
+ 0x00520307: 0x1E58,
+ 0x00720307: 0x1E59,
+ 0x00520323: 0x1E5A,
+ 0x00720323: 0x1E5B,
+ 0x1E5A0304: 0x1E5C,
+ 0x1E5B0304: 0x1E5D,
+ 0x00520331: 0x1E5E,
+ 0x00720331: 0x1E5F,
+ 0x00530307: 0x1E60,
+ 0x00730307: 0x1E61,
+ 0x00530323: 0x1E62,
+ 0x00730323: 0x1E63,
+ 0x015A0307: 0x1E64,
+ 0x015B0307: 0x1E65,
+ 0x01600307: 0x1E66,
+ 0x01610307: 0x1E67,
+ 0x1E620307: 0x1E68,
+ 0x1E630307: 0x1E69,
+ 0x00540307: 0x1E6A,
+ 0x00740307: 0x1E6B,
+ 0x00540323: 0x1E6C,
+ 0x00740323: 0x1E6D,
+ 0x00540331: 0x1E6E,
+ 0x00740331: 0x1E6F,
+ 0x0054032D: 0x1E70,
+ 0x0074032D: 0x1E71,
+ 0x00550324: 0x1E72,
+ 0x00750324: 0x1E73,
+ 0x00550330: 0x1E74,
+ 0x00750330: 0x1E75,
+ 0x0055032D: 0x1E76,
+ 0x0075032D: 0x1E77,
+ 0x01680301: 0x1E78,
+ 0x01690301: 0x1E79,
+ 0x016A0308: 0x1E7A,
+ 0x016B0308: 0x1E7B,
+ 0x00560303: 0x1E7C,
+ 0x00760303: 0x1E7D,
+ 0x00560323: 0x1E7E,
+ 0x00760323: 0x1E7F,
+ 0x00570300: 0x1E80,
+ 0x00770300: 0x1E81,
+ 0x00570301: 0x1E82,
+ 0x00770301: 0x1E83,
+ 0x00570308: 0x1E84,
+ 0x00770308: 0x1E85,
+ 0x00570307: 0x1E86,
+ 0x00770307: 0x1E87,
+ 0x00570323: 0x1E88,
+ 0x00770323: 0x1E89,
+ 0x00580307: 0x1E8A,
+ 0x00780307: 0x1E8B,
+ 0x00580308: 0x1E8C,
+ 0x00780308: 0x1E8D,
+ 0x00590307: 0x1E8E,
+ 0x00790307: 0x1E8F,
+ 0x005A0302: 0x1E90,
+ 0x007A0302: 0x1E91,
+ 0x005A0323: 0x1E92,
+ 0x007A0323: 0x1E93,
+ 0x005A0331: 0x1E94,
+ 0x007A0331: 0x1E95,
+ 0x00680331: 0x1E96,
+ 0x00740308: 0x1E97,
+ 0x0077030A: 0x1E98,
+ 0x0079030A: 0x1E99,
+ 0x017F0307: 0x1E9B,
+ 0x00410323: 0x1EA0,
+ 0x00610323: 0x1EA1,
+ 0x00410309: 0x1EA2,
+ 0x00610309: 0x1EA3,
+ 0x00C20301: 0x1EA4,
+ 0x00E20301: 0x1EA5,
+ 0x00C20300: 0x1EA6,
+ 0x00E20300: 0x1EA7,
+ 0x00C20309: 0x1EA8,
+ 0x00E20309: 0x1EA9,
+ 0x00C20303: 0x1EAA,
+ 0x00E20303: 0x1EAB,
+ 0x1EA00302: 0x1EAC,
+ 0x1EA10302: 0x1EAD,
+ 0x01020301: 0x1EAE,
+ 0x01030301: 0x1EAF,
+ 0x01020300: 0x1EB0,
+ 0x01030300: 0x1EB1,
+ 0x01020309: 0x1EB2,
+ 0x01030309: 0x1EB3,
+ 0x01020303: 0x1EB4,
+ 0x01030303: 0x1EB5,
+ 0x1EA00306: 0x1EB6,
+ 0x1EA10306: 0x1EB7,
+ 0x00450323: 0x1EB8,
+ 0x00650323: 0x1EB9,
+ 0x00450309: 0x1EBA,
+ 0x00650309: 0x1EBB,
+ 0x00450303: 0x1EBC,
+ 0x00650303: 0x1EBD,
+ 0x00CA0301: 0x1EBE,
+ 0x00EA0301: 0x1EBF,
+ 0x00CA0300: 0x1EC0,
+ 0x00EA0300: 0x1EC1,
+ 0x00CA0309: 0x1EC2,
+ 0x00EA0309: 0x1EC3,
+ 0x00CA0303: 0x1EC4,
+ 0x00EA0303: 0x1EC5,
+ 0x1EB80302: 0x1EC6,
+ 0x1EB90302: 0x1EC7,
+ 0x00490309: 0x1EC8,
+ 0x00690309: 0x1EC9,
+ 0x00490323: 0x1ECA,
+ 0x00690323: 0x1ECB,
+ 0x004F0323: 0x1ECC,
+ 0x006F0323: 0x1ECD,
+ 0x004F0309: 0x1ECE,
+ 0x006F0309: 0x1ECF,
+ 0x00D40301: 0x1ED0,
+ 0x00F40301: 0x1ED1,
+ 0x00D40300: 0x1ED2,
+ 0x00F40300: 0x1ED3,
+ 0x00D40309: 0x1ED4,
+ 0x00F40309: 0x1ED5,
+ 0x00D40303: 0x1ED6,
+ 0x00F40303: 0x1ED7,
+ 0x1ECC0302: 0x1ED8,
+ 0x1ECD0302: 0x1ED9,
+ 0x01A00301: 0x1EDA,
+ 0x01A10301: 0x1EDB,
+ 0x01A00300: 0x1EDC,
+ 0x01A10300: 0x1EDD,
+ 0x01A00309: 0x1EDE,
+ 0x01A10309: 0x1EDF,
+ 0x01A00303: 0x1EE0,
+ 0x01A10303: 0x1EE1,
+ 0x01A00323: 0x1EE2,
+ 0x01A10323: 0x1EE3,
+ 0x00550323: 0x1EE4,
+ 0x00750323: 0x1EE5,
+ 0x00550309: 0x1EE6,
+ 0x00750309: 0x1EE7,
+ 0x01AF0301: 0x1EE8,
+ 0x01B00301: 0x1EE9,
+ 0x01AF0300: 0x1EEA,
+ 0x01B00300: 0x1EEB,
+ 0x01AF0309: 0x1EEC,
+ 0x01B00309: 0x1EED,
+ 0x01AF0303: 0x1EEE,
+ 0x01B00303: 0x1EEF,
+ 0x01AF0323: 0x1EF0,
+ 0x01B00323: 0x1EF1,
+ 0x00590300: 0x1EF2,
+ 0x00790300: 0x1EF3,
+ 0x00590323: 0x1EF4,
+ 0x00790323: 0x1EF5,
+ 0x00590309: 0x1EF6,
+ 0x00790309: 0x1EF7,
+ 0x00590303: 0x1EF8,
+ 0x00790303: 0x1EF9,
+ 0x03B10313: 0x1F00,
+ 0x03B10314: 0x1F01,
+ 0x1F000300: 0x1F02,
+ 0x1F010300: 0x1F03,
+ 0x1F000301: 0x1F04,
+ 0x1F010301: 0x1F05,
+ 0x1F000342: 0x1F06,
+ 0x1F010342: 0x1F07,
+ 0x03910313: 0x1F08,
+ 0x03910314: 0x1F09,
+ 0x1F080300: 0x1F0A,
+ 0x1F090300: 0x1F0B,
+ 0x1F080301: 0x1F0C,
+ 0x1F090301: 0x1F0D,
+ 0x1F080342: 0x1F0E,
+ 0x1F090342: 0x1F0F,
+ 0x03B50313: 0x1F10,
+ 0x03B50314: 0x1F11,
+ 0x1F100300: 0x1F12,
+ 0x1F110300: 0x1F13,
+ 0x1F100301: 0x1F14,
+ 0x1F110301: 0x1F15,
+ 0x03950313: 0x1F18,
+ 0x03950314: 0x1F19,
+ 0x1F180300: 0x1F1A,
+ 0x1F190300: 0x1F1B,
+ 0x1F180301: 0x1F1C,
+ 0x1F190301: 0x1F1D,
+ 0x03B70313: 0x1F20,
+ 0x03B70314: 0x1F21,
+ 0x1F200300: 0x1F22,
+ 0x1F210300: 0x1F23,
+ 0x1F200301: 0x1F24,
+ 0x1F210301: 0x1F25,
+ 0x1F200342: 0x1F26,
+ 0x1F210342: 0x1F27,
+ 0x03970313: 0x1F28,
+ 0x03970314: 0x1F29,
+ 0x1F280300: 0x1F2A,
+ 0x1F290300: 0x1F2B,
+ 0x1F280301: 0x1F2C,
+ 0x1F290301: 0x1F2D,
+ 0x1F280342: 0x1F2E,
+ 0x1F290342: 0x1F2F,
+ 0x03B90313: 0x1F30,
+ 0x03B90314: 0x1F31,
+ 0x1F300300: 0x1F32,
+ 0x1F310300: 0x1F33,
+ 0x1F300301: 0x1F34,
+ 0x1F310301: 0x1F35,
+ 0x1F300342: 0x1F36,
+ 0x1F310342: 0x1F37,
+ 0x03990313: 0x1F38,
+ 0x03990314: 0x1F39,
+ 0x1F380300: 0x1F3A,
+ 0x1F390300: 0x1F3B,
+ 0x1F380301: 0x1F3C,
+ 0x1F390301: 0x1F3D,
+ 0x1F380342: 0x1F3E,
+ 0x1F390342: 0x1F3F,
+ 0x03BF0313: 0x1F40,
+ 0x03BF0314: 0x1F41,
+ 0x1F400300: 0x1F42,
+ 0x1F410300: 0x1F43,
+ 0x1F400301: 0x1F44,
+ 0x1F410301: 0x1F45,
+ 0x039F0313: 0x1F48,
+ 0x039F0314: 0x1F49,
+ 0x1F480300: 0x1F4A,
+ 0x1F490300: 0x1F4B,
+ 0x1F480301: 0x1F4C,
+ 0x1F490301: 0x1F4D,
+ 0x03C50313: 0x1F50,
+ 0x03C50314: 0x1F51,
+ 0x1F500300: 0x1F52,
+ 0x1F510300: 0x1F53,
+ 0x1F500301: 0x1F54,
+ 0x1F510301: 0x1F55,
+ 0x1F500342: 0x1F56,
+ 0x1F510342: 0x1F57,
+ 0x03A50314: 0x1F59,
+ 0x1F590300: 0x1F5B,
+ 0x1F590301: 0x1F5D,
+ 0x1F590342: 0x1F5F,
+ 0x03C90313: 0x1F60,
+ 0x03C90314: 0x1F61,
+ 0x1F600300: 0x1F62,
+ 0x1F610300: 0x1F63,
+ 0x1F600301: 0x1F64,
+ 0x1F610301: 0x1F65,
+ 0x1F600342: 0x1F66,
+ 0x1F610342: 0x1F67,
+ 0x03A90313: 0x1F68,
+ 0x03A90314: 0x1F69,
+ 0x1F680300: 0x1F6A,
+ 0x1F690300: 0x1F6B,
+ 0x1F680301: 0x1F6C,
+ 0x1F690301: 0x1F6D,
+ 0x1F680342: 0x1F6E,
+ 0x1F690342: 0x1F6F,
+ 0x03B10300: 0x1F70,
+ 0x03B50300: 0x1F72,
+ 0x03B70300: 0x1F74,
+ 0x03B90300: 0x1F76,
+ 0x03BF0300: 0x1F78,
+ 0x03C50300: 0x1F7A,
+ 0x03C90300: 0x1F7C,
+ 0x1F000345: 0x1F80,
+ 0x1F010345: 0x1F81,
+ 0x1F020345: 0x1F82,
+ 0x1F030345: 0x1F83,
+ 0x1F040345: 0x1F84,
+ 0x1F050345: 0x1F85,
+ 0x1F060345: 0x1F86,
+ 0x1F070345: 0x1F87,
+ 0x1F080345: 0x1F88,
+ 0x1F090345: 0x1F89,
+ 0x1F0A0345: 0x1F8A,
+ 0x1F0B0345: 0x1F8B,
+ 0x1F0C0345: 0x1F8C,
+ 0x1F0D0345: 0x1F8D,
+ 0x1F0E0345: 0x1F8E,
+ 0x1F0F0345: 0x1F8F,
+ 0x1F200345: 0x1F90,
+ 0x1F210345: 0x1F91,
+ 0x1F220345: 0x1F92,
+ 0x1F230345: 0x1F93,
+ 0x1F240345: 0x1F94,
+ 0x1F250345: 0x1F95,
+ 0x1F260345: 0x1F96,
+ 0x1F270345: 0x1F97,
+ 0x1F280345: 0x1F98,
+ 0x1F290345: 0x1F99,
+ 0x1F2A0345: 0x1F9A,
+ 0x1F2B0345: 0x1F9B,
+ 0x1F2C0345: 0x1F9C,
+ 0x1F2D0345: 0x1F9D,
+ 0x1F2E0345: 0x1F9E,
+ 0x1F2F0345: 0x1F9F,
+ 0x1F600345: 0x1FA0,
+ 0x1F610345: 0x1FA1,
+ 0x1F620345: 0x1FA2,
+ 0x1F630345: 0x1FA3,
+ 0x1F640345: 0x1FA4,
+ 0x1F650345: 0x1FA5,
+ 0x1F660345: 0x1FA6,
+ 0x1F670345: 0x1FA7,
+ 0x1F680345: 0x1FA8,
+ 0x1F690345: 0x1FA9,
+ 0x1F6A0345: 0x1FAA,
+ 0x1F6B0345: 0x1FAB,
+ 0x1F6C0345: 0x1FAC,
+ 0x1F6D0345: 0x1FAD,
+ 0x1F6E0345: 0x1FAE,
+ 0x1F6F0345: 0x1FAF,
+ 0x03B10306: 0x1FB0,
+ 0x03B10304: 0x1FB1,
+ 0x1F700345: 0x1FB2,
+ 0x03B10345: 0x1FB3,
+ 0x03AC0345: 0x1FB4,
+ 0x03B10342: 0x1FB6,
+ 0x1FB60345: 0x1FB7,
+ 0x03910306: 0x1FB8,
+ 0x03910304: 0x1FB9,
+ 0x03910300: 0x1FBA,
+ 0x03910345: 0x1FBC,
+ 0x00A80342: 0x1FC1,
+ 0x1F740345: 0x1FC2,
+ 0x03B70345: 0x1FC3,
+ 0x03AE0345: 0x1FC4,
+ 0x03B70342: 0x1FC6,
+ 0x1FC60345: 0x1FC7,
+ 0x03950300: 0x1FC8,
+ 0x03970300: 0x1FCA,
+ 0x03970345: 0x1FCC,
+ 0x1FBF0300: 0x1FCD,
+ 0x1FBF0301: 0x1FCE,
+ 0x1FBF0342: 0x1FCF,
+ 0x03B90306: 0x1FD0,
+ 0x03B90304: 0x1FD1,
+ 0x03CA0300: 0x1FD2,
+ 0x03B90342: 0x1FD6,
+ 0x03CA0342: 0x1FD7,
+ 0x03990306: 0x1FD8,
+ 0x03990304: 0x1FD9,
+ 0x03990300: 0x1FDA,
+ 0x1FFE0300: 0x1FDD,
+ 0x1FFE0301: 0x1FDE,
+ 0x1FFE0342: 0x1FDF,
+ 0x03C50306: 0x1FE0,
+ 0x03C50304: 0x1FE1,
+ 0x03CB0300: 0x1FE2,
+ 0x03C10313: 0x1FE4,
+ 0x03C10314: 0x1FE5,
+ 0x03C50342: 0x1FE6,
+ 0x03CB0342: 0x1FE7,
+ 0x03A50306: 0x1FE8,
+ 0x03A50304: 0x1FE9,
+ 0x03A50300: 0x1FEA,
+ 0x03A10314: 0x1FEC,
+ 0x00A80300: 0x1FED,
+ 0x1F7C0345: 0x1FF2,
+ 0x03C90345: 0x1FF3,
+ 0x03CE0345: 0x1FF4,
+ 0x03C90342: 0x1FF6,
+ 0x1FF60345: 0x1FF7,
+ 0x039F0300: 0x1FF8,
+ 0x03A90300: 0x1FFA,
+ 0x03A90345: 0x1FFC,
+ 0x21900338: 0x219A,
+ 0x21920338: 0x219B,
+ 0x21940338: 0x21AE,
+ 0x21D00338: 0x21CD,
+ 0x21D40338: 0x21CE,
+ 0x21D20338: 0x21CF,
+ 0x22030338: 0x2204,
+ 0x22080338: 0x2209,
+ 0x220B0338: 0x220C,
+ 0x22230338: 0x2224,
+ 0x22250338: 0x2226,
+ 0x223C0338: 0x2241,
+ 0x22430338: 0x2244,
+ 0x22450338: 0x2247,
+ 0x22480338: 0x2249,
+ 0x003D0338: 0x2260,
+ 0x22610338: 0x2262,
+ 0x224D0338: 0x226D,
+ 0x003C0338: 0x226E,
+ 0x003E0338: 0x226F,
+ 0x22640338: 0x2270,
+ 0x22650338: 0x2271,
+ 0x22720338: 0x2274,
+ 0x22730338: 0x2275,
+ 0x22760338: 0x2278,
+ 0x22770338: 0x2279,
+ 0x227A0338: 0x2280,
+ 0x227B0338: 0x2281,
+ 0x22820338: 0x2284,
+ 0x22830338: 0x2285,
+ 0x22860338: 0x2288,
+ 0x22870338: 0x2289,
+ 0x22A20338: 0x22AC,
+ 0x22A80338: 0x22AD,
+ 0x22A90338: 0x22AE,
+ 0x22AB0338: 0x22AF,
+ 0x227C0338: 0x22E0,
+ 0x227D0338: 0x22E1,
+ 0x22910338: 0x22E2,
+ 0x22920338: 0x22E3,
+ 0x22B20338: 0x22EA,
+ 0x22B30338: 0x22EB,
+ 0x22B40338: 0x22EC,
+ 0x22B50338: 0x22ED,
+ 0x304B3099: 0x304C,
+ 0x304D3099: 0x304E,
+ 0x304F3099: 0x3050,
+ 0x30513099: 0x3052,
+ 0x30533099: 0x3054,
+ 0x30553099: 0x3056,
+ 0x30573099: 0x3058,
+ 0x30593099: 0x305A,
+ 0x305B3099: 0x305C,
+ 0x305D3099: 0x305E,
+ 0x305F3099: 0x3060,
+ 0x30613099: 0x3062,
+ 0x30643099: 0x3065,
+ 0x30663099: 0x3067,
+ 0x30683099: 0x3069,
+ 0x306F3099: 0x3070,
+ 0x306F309A: 0x3071,
+ 0x30723099: 0x3073,
+ 0x3072309A: 0x3074,
+ 0x30753099: 0x3076,
+ 0x3075309A: 0x3077,
+ 0x30783099: 0x3079,
+ 0x3078309A: 0x307A,
+ 0x307B3099: 0x307C,
+ 0x307B309A: 0x307D,
+ 0x30463099: 0x3094,
+ 0x309D3099: 0x309E,
+ 0x30AB3099: 0x30AC,
+ 0x30AD3099: 0x30AE,
+ 0x30AF3099: 0x30B0,
+ 0x30B13099: 0x30B2,
+ 0x30B33099: 0x30B4,
+ 0x30B53099: 0x30B6,
+ 0x30B73099: 0x30B8,
+ 0x30B93099: 0x30BA,
+ 0x30BB3099: 0x30BC,
+ 0x30BD3099: 0x30BE,
+ 0x30BF3099: 0x30C0,
+ 0x30C13099: 0x30C2,
+ 0x30C43099: 0x30C5,
+ 0x30C63099: 0x30C7,
+ 0x30C83099: 0x30C9,
+ 0x30CF3099: 0x30D0,
+ 0x30CF309A: 0x30D1,
+ 0x30D23099: 0x30D3,
+ 0x30D2309A: 0x30D4,
+ 0x30D53099: 0x30D6,
+ 0x30D5309A: 0x30D7,
+ 0x30D83099: 0x30D9,
+ 0x30D8309A: 0x30DA,
+ 0x30DB3099: 0x30DC,
+ 0x30DB309A: 0x30DD,
+ 0x30A63099: 0x30F4,
+ 0x30EF3099: 0x30F7,
+ 0x30F03099: 0x30F8,
+ 0x30F13099: 0x30F9,
+ 0x30F23099: 0x30FA,
+ 0x30FD3099: 0x30FE,
+ 0x109910BA: 0x1109A,
+ 0x109B10BA: 0x1109C,
+ 0x10A510BA: 0x110AB,
+ 0x11311127: 0x1112E,
+ 0x11321127: 0x1112F,
+}
+
+// Total size of tables: 50KB (51625 bytes)
diff --git a/src/pkg/exp/norm/trie.go b/src/pkg/exp/norm/trie.go
new file mode 100644
index 000000000..82267a8d3
--- /dev/null
+++ b/src/pkg/exp/norm/trie.go
@@ -0,0 +1,232 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+type valueRange struct {
+ value uint16 // header: value:stride
+ lo, hi byte // header: lo:n
+}
+
+type trie struct {
+ index []uint8
+ values []uint16
+ sparse []valueRange
+ sparseOffset []uint16
+ cutoff uint8 // indices >= cutoff are sparse
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
+// is a list of ranges with an accompanying value. Given a matching range r,
+// the value for b is by r.value + (b - r.lo) * stride.
+func (t *trie) lookupValue(n uint8, b byte) uint16 {
+ if n < t.cutoff {
+ return t.values[uint16(n)<<6+uint16(b)]
+ }
+ offset := t.sparseOffset[n-t.cutoff]
+ header := t.sparse[offset]
+ lo := offset + 1
+ hi := lo + uint16(header.lo)
+ for lo < hi {
+ m := lo + (hi-lo)/2
+ r := t.sparse[m]
+ if r.lo <= b && b <= r.hi {
+ return r.value + uint16(b-r.lo)*header.value
+ }
+ if b < r.lo {
+ hi = m
+ } else {
+ lo = m + 1
+ }
+ }
+ return 0
+}
+
+const (
+ t1 = 0x00 // 0000 0000
+ tx = 0x80 // 1000 0000
+ t2 = 0xC0 // 1100 0000
+ t3 = 0xE0 // 1110 0000
+ t4 = 0xF0 // 1111 0000
+ t5 = 0xF8 // 1111 1000
+ t6 = 0xFC // 1111 1100
+ te = 0xFE // 1111 1110
+)
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *trie) lookup(s []byte) (v uint16, sz int) {
+ c0 := s[0]
+ switch {
+ case c0 < tx:
+ return t.values[c0], 1
+ case c0 < t2:
+ return 0, 1
+ case c0 < t3:
+ if len(s) < 2 {
+ return 0, 0
+ }
+ i := t.index[c0]
+ c1 := s[1]
+ if c1 < tx || t2 <= c1 {
+ return 0, 1
+ }
+ return t.lookupValue(i, c1), 2
+ case c0 < t4:
+ if len(s) < 3 {
+ return 0, 0
+ }
+ i := t.index[c0]
+ c1 := s[1]
+ if c1 < tx || t2 <= c1 {
+ return 0, 1
+ }
+ o := uint16(i)<<6 + uint16(c1)
+ i = t.index[o]
+ c2 := s[2]
+ if c2 < tx || t2 <= c2 {
+ return 0, 2
+ }
+ return t.lookupValue(i, c2), 3
+ case c0 < t5:
+ if len(s) < 4 {
+ return 0, 0
+ }
+ i := t.index[c0]
+ c1 := s[1]
+ if c1 < tx || t2 <= c1 {
+ return 0, 1
+ }
+ o := uint16(i)<<6 + uint16(c1)
+ i = t.index[o]
+ c2 := s[2]
+ if c2 < tx || t2 <= c2 {
+ return 0, 2
+ }
+ o = uint16(i)<<6 + uint16(c2)
+ i = t.index[o]
+ c3 := s[3]
+ if c3 < tx || t2 <= c3 {
+ return 0, 3
+ }
+ return t.lookupValue(i, c3), 4
+ }
+ // Illegal rune
+ return 0, 1
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *trie) lookupString(s string) (v uint16, sz int) {
+ c0 := s[0]
+ switch {
+ case c0 < tx:
+ return t.values[c0], 1
+ case c0 < t2:
+ return 0, 1
+ case c0 < t3:
+ if len(s) < 2 {
+ return 0, 0
+ }
+ i := t.index[c0]
+ c1 := s[1]
+ if c1 < tx || t2 <= c1 {
+ return 0, 1
+ }
+ return t.lookupValue(i, c1), 2
+ case c0 < t4:
+ if len(s) < 3 {
+ return 0, 0
+ }
+ i := t.index[c0]
+ c1 := s[1]
+ if c1 < tx || t2 <= c1 {
+ return 0, 1
+ }
+ o := uint16(i)<<6 + uint16(c1)
+ i = t.index[o]
+ c2 := s[2]
+ if c2 < tx || t2 <= c2 {
+ return 0, 2
+ }
+ return t.lookupValue(i, c2), 3
+ case c0 < t5:
+ if len(s) < 4 {
+ return 0, 0
+ }
+ i := t.index[c0]
+ c1 := s[1]
+ if c1 < tx || t2 <= c1 {
+ return 0, 1
+ }
+ o := uint16(i)<<6 + uint16(c1)
+ i = t.index[o]
+ c2 := s[2]
+ if c2 < tx || t2 <= c2 {
+ return 0, 2
+ }
+ o = uint16(i)<<6 + uint16(c2)
+ i = t.index[o]
+ c3 := s[3]
+ if c3 < tx || t2 <= c3 {
+ return 0, 3
+ }
+ return t.lookupValue(i, c3), 4
+ }
+ // Illegal rune
+ return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must hold a full encoding.
+func (t *trie) lookupUnsafe(s []byte) uint16 {
+ c0 := s[0]
+ if c0 < tx {
+ return t.values[c0]
+ }
+ if c0 < t2 {
+ return 0
+ }
+ i := t.index[c0]
+ if c0 < t3 {
+ return t.lookupValue(i, s[1])
+ }
+ i = t.index[uint16(i)<<6+uint16(s[1])]
+ if c0 < t4 {
+ return t.lookupValue(i, s[2])
+ }
+ i = t.index[uint16(i)<<6+uint16(s[2])]
+ if c0 < t5 {
+ return t.lookupValue(i, s[3])
+ }
+ return 0
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must hold a full encoding.
+func (t *trie) lookupStringUnsafe(s string) uint16 {
+ c0 := s[0]
+ if c0 < tx {
+ return t.values[c0]
+ }
+ if c0 < t2 {
+ return 0
+ }
+ i := t.index[c0]
+ if c0 < t3 {
+ return t.lookupValue(i, s[1])
+ }
+ i = t.index[uint16(i)<<6+uint16(s[1])]
+ if c0 < t4 {
+ return t.lookupValue(i, s[2])
+ }
+ i = t.index[uint16(i)<<6+uint16(s[2])]
+ if c0 < t5 {
+ return t.lookupValue(i, s[3])
+ }
+ return 0
+}
diff --git a/src/pkg/exp/norm/trie_test.go b/src/pkg/exp/norm/trie_test.go
new file mode 100644
index 000000000..1a75cc705
--- /dev/null
+++ b/src/pkg/exp/norm/trie_test.go
@@ -0,0 +1,152 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+ "testing"
+ "unicode/utf8"
+)
+
+// Test data is located in triedata_test.go; generated by maketesttables.
+var testdata = testdataTrie
+
+type rangeTest struct {
+ block uint8
+ lookup byte
+ result uint16
+ table []valueRange
+ offsets []uint16
+}
+
+var range1Off = []uint16{0, 2}
+var range1 = []valueRange{
+ {0, 1, 0},
+ {1, 0x80, 0x80},
+ {0, 2, 0},
+ {1, 0x80, 0x80},
+ {9, 0xff, 0xff},
+}
+
+var rangeTests = []rangeTest{
+ {10, 0x80, 1, range1, range1Off},
+ {10, 0x00, 0, range1, range1Off},
+ {11, 0x80, 1, range1, range1Off},
+ {11, 0xff, 9, range1, range1Off},
+ {11, 0x00, 0, range1, range1Off},
+}
+
+func TestLookupSparse(t *testing.T) {
+ for i, test := range rangeTests {
+ n := trie{sparse: test.table, sparseOffset: test.offsets, cutoff: 10}
+ v := n.lookupValue(test.block, test.lookup)
+ if v != test.result {
+ t.Errorf("LookupSparse:%d: found %X; want %X", i, v, test.result)
+ }
+ }
+}
+
+// Test cases for illegal runes.
+type trietest struct {
+ size int
+ bytes []byte
+}
+
+var tests = []trietest{
+ // illegal runes
+ {1, []byte{0x80}},
+ {1, []byte{0xFF}},
+ {1, []byte{t2, tx - 1}},
+ {1, []byte{t2, t2}},
+ {2, []byte{t3, tx, tx - 1}},
+ {2, []byte{t3, tx, t2}},
+ {1, []byte{t3, tx - 1, tx}},
+ {3, []byte{t4, tx, tx, tx - 1}},
+ {3, []byte{t4, tx, tx, t2}},
+ {1, []byte{t4, t2, tx, tx - 1}},
+ {2, []byte{t4, tx, t2, tx - 1}},
+
+ // short runes
+ {0, []byte{t2}},
+ {0, []byte{t3, tx}},
+ {0, []byte{t4, tx, tx}},
+
+ // we only support UTF-8 up to utf8.UTFMax bytes (4 bytes)
+ {1, []byte{t5, tx, tx, tx, tx}},
+ {1, []byte{t6, tx, tx, tx, tx, tx}},
+}
+
+func mkUTF8(r rune) ([]byte, int) {
+ var b [utf8.UTFMax]byte
+ sz := utf8.EncodeRune(b[:], r)
+ return b[:sz], sz
+}
+
+func TestLookup(t *testing.T) {
+ for i, tt := range testRunes {
+ b, szg := mkUTF8(tt)
+ v, szt := testdata.lookup(b)
+ if int(v) != i {
+ t.Errorf("lookup(%U): found value %#x, expected %#x", tt, v, i)
+ }
+ if szt != szg {
+ t.Errorf("lookup(%U): found size %d, expected %d", tt, szt, szg)
+ }
+ }
+ for i, tt := range tests {
+ v, sz := testdata.lookup(tt.bytes)
+ if v != 0 {
+ t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
+ }
+ if sz != tt.size {
+ t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
+ }
+ }
+ // Verify defaults.
+ if v, _ := testdata.lookup([]byte{0xC1, 0x8C}); v != 0 {
+ t.Errorf("lookup of non-existing rune should be 0; found %X", v)
+ }
+}
+
+func TestLookupUnsafe(t *testing.T) {
+ for i, tt := range testRunes {
+ b, _ := mkUTF8(tt)
+ v := testdata.lookupUnsafe(b)
+ if int(v) != i {
+ t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
+ }
+ }
+}
+
+func TestLookupString(t *testing.T) {
+ for i, tt := range testRunes {
+ b, szg := mkUTF8(tt)
+ v, szt := testdata.lookupString(string(b))
+ if int(v) != i {
+ t.Errorf("lookup(%U): found value %#x, expected %#x", i, v, i)
+ }
+ if szt != szg {
+ t.Errorf("lookup(%U): found size %d, expected %d", i, szt, szg)
+ }
+ }
+ for i, tt := range tests {
+ v, sz := testdata.lookupString(string(tt.bytes))
+ if int(v) != 0 {
+ t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
+ }
+ if sz != tt.size {
+ t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
+ }
+ }
+}
+
+func TestLookupStringUnsafe(t *testing.T) {
+ for i, tt := range testRunes {
+ b, _ := mkUTF8(tt)
+ v := testdata.lookupStringUnsafe(string(b))
+ if int(v) != i {
+ t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
+ }
+ }
+}
diff --git a/src/pkg/exp/norm/triedata_test.go b/src/pkg/exp/norm/triedata_test.go
new file mode 100644
index 000000000..d6c832d46
--- /dev/null
+++ b/src/pkg/exp/norm/triedata_test.go
@@ -0,0 +1,85 @@
+// Generated by running
+// maketesttables
+// DO NOT EDIT
+
+package norm
+
+var testRunes = []int32{1, 12, 127, 128, 256, 2047, 2048, 2457, 65535, 65536, 65793, 1114111, 512, 513, 514, 528, 533}
+
+// testdataValues: 192 entries, 384 bytes
+// Block 2 is the null block.
+var testdataValues = [192]uint16{
+ // Block 0x0, offset 0x0
+ 0x000c: 0x0001,
+ // Block 0x1, offset 0x40
+ 0x007f: 0x0002,
+ // Block 0x2, offset 0x80
+}
+
+// testdataSparseOffset: 10 entries, 20 bytes
+var testdataSparseOffset = []uint16{0x0, 0x2, 0x4, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14}
+
+// testdataSparseValues: 22 entries, 88 bytes
+var testdataSparseValues = [22]valueRange{
+ // Block 0x0, offset 0x1
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0003, lo: 0x80, hi: 0x80},
+ // Block 0x1, offset 0x2
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0004, lo: 0x80, hi: 0x80},
+ // Block 0x2, offset 0x3
+ {value: 0x0001, lo: 0x03},
+ {value: 0x000c, lo: 0x80, hi: 0x82},
+ {value: 0x000f, lo: 0x90, hi: 0x90},
+ {value: 0x0010, lo: 0x95, hi: 0x95},
+ // Block 0x3, offset 0x4
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0005, lo: 0xbf, hi: 0xbf},
+ // Block 0x4, offset 0x5
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0006, lo: 0x80, hi: 0x80},
+ // Block 0x5, offset 0x6
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0007, lo: 0x99, hi: 0x99},
+ // Block 0x6, offset 0x7
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0008, lo: 0xbf, hi: 0xbf},
+ // Block 0x7, offset 0x8
+ {value: 0x0000, lo: 0x01},
+ {value: 0x0009, lo: 0x80, hi: 0x80},
+ // Block 0x8, offset 0x9
+ {value: 0x0000, lo: 0x01},
+ {value: 0x000a, lo: 0x81, hi: 0x81},
+ // Block 0x9, offset 0xa
+ {value: 0x0000, lo: 0x01},
+ {value: 0x000b, lo: 0xbf, hi: 0xbf},
+}
+
+// testdataLookup: 640 bytes
+// Block 0 is the null block.
+var testdataLookup = [640]uint8{
+ // Block 0x0, offset 0x0
+ // Block 0x1, offset 0x40
+ // Block 0x2, offset 0x80
+ // Block 0x3, offset 0xc0
+ 0x0c2: 0x01, 0x0c4: 0x02,
+ 0x0c8: 0x03,
+ 0x0df: 0x04,
+ 0x0e0: 0x02,
+ 0x0ef: 0x03,
+ 0x0f0: 0x05, 0x0f4: 0x07,
+ // Block 0x4, offset 0x100
+ 0x120: 0x05, 0x126: 0x06,
+ // Block 0x5, offset 0x140
+ 0x17f: 0x07,
+ // Block 0x6, offset 0x180
+ 0x180: 0x08, 0x184: 0x09,
+ // Block 0x7, offset 0x1c0
+ 0x1d0: 0x04,
+ // Block 0x8, offset 0x200
+ 0x23f: 0x0a,
+ // Block 0x9, offset 0x240
+ 0x24f: 0x06,
+}
+
+var testdataTrie = trie{testdataLookup[:], testdataValues[:], testdataSparseValues[:], testdataSparseOffset[:], 1}
diff --git a/src/pkg/exp/norm/triegen.go b/src/pkg/exp/norm/triegen.go
new file mode 100644
index 000000000..52c88b039
--- /dev/null
+++ b/src/pkg/exp/norm/triegen.go
@@ -0,0 +1,317 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// Trie table generator.
+// Used by make*tables tools to generate a go file with trie data structures
+// for mapping UTF-8 to a 16-bit value. All but the last byte in a UTF-8 byte
+// sequence are used to lookup offsets in the index table to be used for the
+// next byte. The last byte is used to index into a table with 16-bit values.
+
+package main
+
+import (
+ "fmt"
+ "hash/crc32"
+ "log"
+ "unicode/utf8"
+)
+
+const (
+ blockSize = 64
+ blockOffset = 2 // Subtract two blocks to compensate for the 0x80 added to continuation bytes.
+ maxSparseEntries = 16
+)
+
+// Intermediate trie structure
+type trieNode struct {
+ table [256]*trieNode
+ value int
+ b byte
+ leaf bool
+}
+
+func newNode() *trieNode {
+ return new(trieNode)
+}
+
+func (n trieNode) String() string {
+ s := fmt.Sprint("trieNode{table: { non-nil at index: ")
+ for i, v := range n.table {
+ if v != nil {
+ s += fmt.Sprintf("%d, ", i)
+ }
+ }
+ s += fmt.Sprintf("}, value:%#x, b:%#x leaf:%v}", n.value, n.b, n.leaf)
+ return s
+}
+
+func (n trieNode) isInternal() bool {
+ internal := true
+ for i := 0; i < 256; i++ {
+ if nn := n.table[i]; nn != nil {
+ if !internal && !nn.leaf {
+ log.Fatalf("triegen: isInternal: node contains both leaf and non-leaf children (%v)", n)
+ }
+ internal = internal && !nn.leaf
+ }
+ }
+ return internal
+}
+
+func (n trieNode) mostFrequentStride() int {
+ counts := make(map[int]int)
+ v := 0
+ for _, t := range n.table[0x80 : 0x80+blockSize] {
+ if t != nil {
+ if stride := t.value - v; v != 0 && stride >= 0 {
+ counts[stride]++
+ }
+ v = t.value
+ } else {
+ v = 0
+ }
+ }
+ var maxs, maxc int
+ for stride, cnt := range counts {
+ if cnt > maxc || (cnt == maxc && stride < maxs) {
+ maxs, maxc = stride, cnt
+ }
+ }
+ return maxs
+}
+
+func (n trieNode) countSparseEntries() int {
+ stride := n.mostFrequentStride()
+ var count, v int
+ for _, t := range n.table[0x80 : 0x80+blockSize] {
+ tv := 0
+ if t != nil {
+ tv = t.value
+ }
+ if tv-v != stride {
+ if tv != 0 {
+ count++
+ }
+ }
+ v = tv
+ }
+ return count
+}
+
+func (n *trieNode) insert(r rune, value uint16) {
+ var p [utf8.UTFMax]byte
+ sz := utf8.EncodeRune(p[:], r)
+
+ for i := 0; i < sz; i++ {
+ if n.leaf {
+ log.Fatalf("triegen: insert: node (%#v) should not be a leaf", n)
+ }
+ nn := n.table[p[i]]
+ if nn == nil {
+ nn = newNode()
+ nn.b = p[i]
+ n.table[p[i]] = nn
+ }
+ n = nn
+ }
+ n.value = int(value)
+ n.leaf = true
+}
+
+type nodeIndex struct {
+ lookupBlocks []*trieNode
+ valueBlocks []*trieNode
+ sparseBlocks []*trieNode
+ sparseOffset []uint16
+ sparseCount int
+
+ lookupBlockIdx map[uint32]int
+ valueBlockIdx map[uint32]int
+}
+
+func newIndex() *nodeIndex {
+ index := &nodeIndex{}
+ index.lookupBlocks = make([]*trieNode, 0)
+ index.valueBlocks = make([]*trieNode, 0)
+ index.sparseBlocks = make([]*trieNode, 0)
+ index.sparseOffset = make([]uint16, 1)
+ index.lookupBlockIdx = make(map[uint32]int)
+ index.valueBlockIdx = make(map[uint32]int)
+ return index
+}
+
+func computeOffsets(index *nodeIndex, n *trieNode) int {
+ if n.leaf {
+ return n.value
+ }
+ hasher := crc32.New(crc32.MakeTable(crc32.IEEE))
+ // We only index continuation bytes.
+ for i := 0; i < blockSize; i++ {
+ v := 0
+ if nn := n.table[0x80+i]; nn != nil {
+ v = computeOffsets(index, nn)
+ }
+ hasher.Write([]byte{uint8(v >> 8), uint8(v)})
+ }
+ h := hasher.Sum32()
+ if n.isInternal() {
+ v, ok := index.lookupBlockIdx[h]
+ if !ok {
+ v = len(index.lookupBlocks) - blockOffset
+ index.lookupBlocks = append(index.lookupBlocks, n)
+ index.lookupBlockIdx[h] = v
+ }
+ n.value = v
+ } else {
+ v, ok := index.valueBlockIdx[h]
+ if !ok {
+ if c := n.countSparseEntries(); c > maxSparseEntries {
+ v = len(index.valueBlocks) - blockOffset
+ index.valueBlocks = append(index.valueBlocks, n)
+ index.valueBlockIdx[h] = v
+ } else {
+ v = -len(index.sparseOffset)
+ index.sparseBlocks = append(index.sparseBlocks, n)
+ index.sparseOffset = append(index.sparseOffset, uint16(index.sparseCount))
+ index.sparseCount += c + 1
+ index.valueBlockIdx[h] = v
+ }
+ }
+ n.value = v
+ }
+ return n.value
+}
+
+func printValueBlock(nr int, n *trieNode, offset int) {
+ boff := nr * blockSize
+ fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
+ var printnewline bool
+ for i := 0; i < blockSize; i++ {
+ if i%6 == 0 {
+ printnewline = true
+ }
+ v := 0
+ if nn := n.table[i+offset]; nn != nil {
+ v = nn.value
+ }
+ if v != 0 {
+ if printnewline {
+ fmt.Printf("\n")
+ printnewline = false
+ }
+ fmt.Printf("%#04x:%#04x, ", boff+i, v)
+ }
+ }
+}
+
+func printSparseBlock(nr int, n *trieNode) {
+ boff := -n.value
+ fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
+ v := 0
+ //stride := f(n)
+ stride := n.mostFrequentStride()
+ c := n.countSparseEntries()
+ fmt.Printf("\n{value:%#04x,lo:%#02x},", stride, uint8(c))
+ for i, nn := range n.table[0x80 : 0x80+blockSize] {
+ nv := 0
+ if nn != nil {
+ nv = nn.value
+ }
+ if nv-v != stride {
+ if v != 0 {
+ fmt.Printf(",hi:%#02x},", 0x80+i-1)
+ }
+ if nv != 0 {
+ fmt.Printf("\n{value:%#04x,lo:%#02x", nv, nn.b)
+ }
+ }
+ v = nv
+ }
+ if v != 0 {
+ fmt.Printf(",hi:%#02x},", 0x80+blockSize-1)
+ }
+}
+
+func printLookupBlock(nr int, n *trieNode, offset, cutoff int) {
+ boff := nr * blockSize
+ fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
+ var printnewline bool
+ for i := 0; i < blockSize; i++ {
+ if i%8 == 0 {
+ printnewline = true
+ }
+ v := 0
+ if nn := n.table[i+offset]; nn != nil {
+ v = nn.value
+ }
+ if v != 0 {
+ if v < 0 {
+ v = -v - 1 + cutoff
+ }
+ if printnewline {
+ fmt.Printf("\n")
+ printnewline = false
+ }
+ fmt.Printf("%#03x:%#02x, ", boff+i, v)
+ }
+ }
+}
+
+// printTables returns the size in bytes of the generated tables.
+func (t *trieNode) printTables(name string) int {
+ index := newIndex()
+ // Values for 7-bit ASCII are stored in first two block, followed by nil block.
+ index.valueBlocks = append(index.valueBlocks, nil, nil, nil)
+ // First byte of multi-byte UTF-8 codepoints are indexed in 4th block.
+ index.lookupBlocks = append(index.lookupBlocks, nil, nil, nil, nil)
+ // Index starter bytes of multi-byte UTF-8.
+ for i := 0xC0; i < 0x100; i++ {
+ if t.table[i] != nil {
+ computeOffsets(index, t.table[i])
+ }
+ }
+
+ nv := len(index.valueBlocks) * blockSize
+ fmt.Printf("// %sValues: %d entries, %d bytes\n", name, nv, nv*2)
+ fmt.Printf("// Block 2 is the null block.\n")
+ fmt.Printf("var %sValues = [%d]uint16 {", name, nv)
+ printValueBlock(0, t, 0)
+ printValueBlock(1, t, 64)
+ printValueBlock(2, newNode(), 0)
+ for i := 3; i < len(index.valueBlocks); i++ {
+ printValueBlock(i, index.valueBlocks[i], 0x80)
+ }
+ fmt.Print("\n}\n\n")
+
+ ls := len(index.sparseBlocks)
+ fmt.Printf("// %sSparseOffset: %d entries, %d bytes\n", name, ls, ls*2)
+ fmt.Printf("var %sSparseOffset = %#v\n\n", name, index.sparseOffset[1:])
+
+ ns := index.sparseCount
+ fmt.Printf("// %sSparseValues: %d entries, %d bytes\n", name, ns, ns*4)
+ fmt.Printf("var %sSparseValues = [%d]valueRange {", name, ns)
+ for i, n := range index.sparseBlocks {
+ printSparseBlock(i, n)
+ }
+ fmt.Print("\n}\n\n")
+
+ cutoff := len(index.valueBlocks) - blockOffset
+ ni := len(index.lookupBlocks) * blockSize
+ fmt.Printf("// %sLookup: %d bytes\n", name, ni)
+ fmt.Printf("// Block 0 is the null block.\n")
+ fmt.Printf("var %sLookup = [%d]uint8 {", name, ni)
+ printLookupBlock(0, newNode(), 0, cutoff)
+ printLookupBlock(1, newNode(), 0, cutoff)
+ printLookupBlock(2, newNode(), 0, cutoff)
+ printLookupBlock(3, t, 0xC0, cutoff)
+ for i := 4; i < len(index.lookupBlocks); i++ {
+ printLookupBlock(i, index.lookupBlocks[i], 0x80, cutoff)
+ }
+ fmt.Print("\n}\n\n")
+ fmt.Printf("var %sTrie = trie{ %sLookup[:], %sValues[:], %sSparseValues[:], %sSparseOffset[:], %d}\n\n",
+ name, name, name, name, name, cutoff)
+ return nv*2 + ns*4 + ni + ls*2
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-09-13 00:50:00 +0000